Http Load Testing - scala

Question

I am trying to create a simple microservice that can handle 1 million requests at a time. But I am getting connection reset error on my client side. Correct me in case I am making any mistake.
Server Code
1. Listener :
object Collection {
case class calculate(values:Double)
}
object EngineController{
import Collection._
def main(args: Array[String]): Unit = {
try {
implicit val system = ActorSystem()
implicit val materializer = ActorMaterializer()
implicit val executionContext = system.dispatcher
val requestHandler = system.actorOf(RoundRobinPool(3).props(RequestHandler.props), "round-robin-pool")
val route: Route = {
implicit val timeout = Timeout(100.seconds)
path("aggregate") {
log.info("REQUEST RECEIVED")
post {
entity(as[String]) { values =>
onSuccess(requestHandler ? calculate(values)) {
case result: Double =>
log.info("Response Sent -" + result)
complete(s"${result}")
}
}
}
}
}
val routeBinding :Future[ServerBinding] = Http().bindAndHandle(route, "localhost", 8080)
log.info("Connection Established! Waiting for Request")
routeBinding.failed.foreach { ex =>
log.error(ex, "Failed to bind to {}:{}!", host, port)
}
StdIn.readLine()
routeBinding.flatMap(_.unbind())
system.terminate()
}
catch {
case ex: Exception =>
log.error(ex, ex)
}
}
}
RequestHandler: This actor return max of the number.
object RequestHandler extends App {
def props: Props = {
Props(classOf[RequestHandler])
}
class RequestHandler extends Actor {
var doubleArray: Array[Double] = Array.empty
val system1 = ActorSystem("system2")
var routees: List[ActorRef] = _
override def preStart() = {
routees = List.fill(5)(
context.actorOf(AggregateCalculator.props)
)
}
val aggregateActor = system1.actorOf(AggregateCalculator.props.withRouter(RandomPool(100)), "ag")
//CONVERT STRING TO ARRAY
def stringToArray(values: String): Array[Double] = {
return values.split(",").map(x => x.toDouble)
}
override def receive: Receive = {
case calculate(values) =>
doubleArray = stringToArray(values)
sender() ! doubleArray.max
}
}
}
Client Code :
package Test
import scalaj.http.{Http, HttpResponse}
import org.apache.log4j.Logger
//libraryDependencies += "org.scalaj" % "scalaj-http_2.11" % "2.3.0"
object RequestSender1 {
val log = Logger.getLogger(getClass.getName)
def main(args: Array[String]): Unit = {
try {
val str = "22.78, -1.23, 50, 60, 3, 32, 11, 54, 72, 78, 99, 70, 19, 47, 90, 81, 50, 69, 69, 72, 83, 14.7, 8, 41, 65, 73, 48, 63, 47, 17, 55, 39, 50, 87, 76, 8, 67, 51, 55, 94, 75, 14, 91, 35, 87, 36, 42, 74, 70, 81, 18, 14, 50, 22, 16, 55, 71, 17, 39, 44, 58, 61, 16, 4, 74, 61, 37, 31, 62, 36, 53, 30, 82, 72, 89, 96, 28, 36, 77, 89, 30, 2, 31, 79, 50, 34, 81, 39, 91, 85, 94, 25, 68, 98, 46, 42,14,14"
var result: HttpResponse[String] = null
var counter = 0
for (i <- 1 to 300) {
for (i <- 1 to 13000) {
val thread = new Thread {
override def run {
while (counter < 1000024) {
try {
counter += 1
result = scalaj.http.Http("http://localhost:8080/aggregate").postData(str).timeout(1200000, 120000000) //192.168.0.157:8089
.header("Content-Type", "text/plain").asString
println("Thread Count----" + java.lang.Thread.activeCount())
j += 1
println(result.body + " " + j)
} catch {
case ex:Exception =>
log.error(ex)
}
}
}
}
thread.start
// slow the loop down a bit
}
println("Sent request with --" + i)
Thread.sleep(1)
// slow the loop down a bit
}
}
catch {
case ex:Exception =>
println("Exception"+">>>>>>>>>>")
}
}
}
Error 1 :
09:58:07 ERROR [Thread-12803] - Test.RequestSender1$.run 32 - java.net.BindException: Address already in use: connect
Error 2 :
Thread-12418" java.net.SocketException: Connection reset
Sorry for Bad Allignment

Answer 1

I think this has nothing to do with Scala or HTTP. It is a limitation of the TCP protocol.
Unfortunately you just can't create 1 million outbound TCP connections from a single machine. TCP connection is specified by two pairs (IP address, port) for client and server. The server might have all connections coming to the same port and distinguish them by the client information. But for any typical TCP/IP implementation each outbound connection will have its own unique TCP port assigned to it (and even if you roll out some custom implementation you still can't have two outgoing connections to the same server/port from the same client/port because they will be indistinguishable). TCP port is actually just a 16-bit number. It means there are only about 65k ports altogether which is obviously much less than 1 million you want. So to make 1 million connections you will require many machines (or at least virtual machines) running the test at the same time.