//设置package包名称以及导入依赖的类
package se.gigurra.dcs.remote

import java.time.Instant

import com.google.common.cache.CacheBuilder
import com.google.common.cache.Cache
import com.twitter.io.Buf

import scala.collection.concurrent
import scala.collection.JavaConversions._

case class ResourceCache(maxItemsPerCategory: Int) {

  private val categories = new concurrent.TrieMap[String, Cache[String, CacheItem]]

  def put(category: String, id: String, _data: Buf): Unit = {
    val data = Buf.ByteArray.coerce(_data)
    categories.getOrElseUpdate(category, newCategory()).put(id, CacheItem(id, data, time))
  }

  def get(category: String, id: String, maxAgeSeconds: Double): Option[CacheItem] = {
    categories.get(category).flatMap(c => Option(c.getIfPresent(id))).filter(_.age <= maxAgeSeconds)
  }

  def delete(category: String, id: String): Unit = {
    categories.get(category).foreach(_.invalidate(id))
  }

  def getCategory(category: String, maxAgeSeconds: Double): Seq[CacheItem] = {
    categories.get(category).map { c =>
      c.asMap().values().filter(_.age <= maxAgeSeconds).toSeq
    }.getOrElse(Nil)
  }

  def categoryNames: Seq[String] = {
    categories.keys.toSeq
  }

  private def time: Double = Instant.now.toEpochMilli.toDouble / 1000.0
  private def newCategory() = CacheBuilder.newBuilder().maximumSize(maxItemsPerCategory).build[String, CacheItem]()
}

case class CacheItem(id: String, data: Buf, timestamp: Double) {
  def age: Double = time - timestamp
  private def time: Double = Instant.now.toEpochMilli.toDouble / 1000.0
} 

//设置package包名称以及导入依赖的类
package com.lookout.ratelimitingfilter

import com.twitter.finagle.http.{Response, Status}
import com.twitter.finagle.RefusedByRateLimiter
import com.twitter.io.Buf
import com.twitter.logging.Logger
import io.circe.{Decoder, Encoder}
import io.circe.syntax._

final case class RefusedByRateLimiterError(
  message: String
) extends Exception(message) {
  def toResponse: Response = RefusedByRateLimiterError.toResponse(this)
}

object RefusedByRateLimiterError {
  val LOG = Logger.get(getClass)

  implicit val errorEncoder: Encoder[RefusedByRateLimiterError] =
    Encoder.forProduct1("message") { err => err.message }

  implicit val errorDecoder: Decoder[RefusedByRateLimiterError] =
    Decoder.forProduct1[String, RefusedByRateLimiterError]("message") {
      case (message: String) => RefusedByRateLimiterError(message)
    }

  def toResponse(error: RefusedByRateLimiterError): Response = {
    val response = Response(Status.TooManyRequests)
    val content = error.asJson.noSpaces
    LOG.info(content)
    response.content = Buf.Utf8(content)
    response.contentType = "application/json"
    response
  }
} 

//设置package包名称以及导入依赖的类
package net.gutefrage.context

import com.twitter.finagle.context.Contexts
import com.twitter.finagle.util.ByteArrays
import com.twitter.io.Buf
import com.twitter.util.{Return, Throw, Try}

case class UserContext(userId: Long)


  def current: Option[UserContext] = Contexts.broadcast.get(UserContext)

  override def marshal(userContext: UserContext): Buf = {
    val bytes = new Array[Byte](bodyLengthBytes)
    ByteArrays.put64be(bytes, 0, userContext.userId)
    Buf.ByteArray.Owned(bytes)
  }

  override def tryUnmarshal(body: Buf): Try[UserContext] = {
    if (body.length != bodyLengthBytes) {
      return Throw(new IllegalArgumentException(s"Invalid body. Length ${body.length} but required 16"))
    }

    val bytes = Buf.ByteArray.Owned.extract(body)
    val userId = ByteArrays.get64be(bytes, 0)

    Return(UserContext(userId))
  }
} 

//设置package包名称以及导入依赖的类
package uk.co.appministry.scathon.testServer.plugins

import uk.co.appministry.scathon.models.v2.Plugin
import com.twitter.finagle.http.{Request, Status, Response}
import com.twitter.io.{Buf, Reader}
import play.api.libs.json.{JsString, Json}

trait TPlugin {

  def info: Plugin
  def get(request: Request, path: String): Response = Response(Status.NoContent)
  def put(request: Request, path: String): Response = Response(Status.NoContent)
  def post(request: Request, path: String): Response = Response(Status.NoContent)
  def delete(request: Request, path: String): Response = Response(Status.NoContent)

}

class TestPlugin extends TPlugin {

  def info: Plugin = {
    Plugin(
      id = "test-plugin",
      plugin = this.getClass.getName,
      implementation = this.getClass.getName,
      tags = Some(List("test", "plugin")),
      info = Some(Map("test" -> JsString("value")))
    )
  }

  override def get(request: Request, path: String): Response = {
    Response(request.version, Status.Ok, Reader.fromBuf(Buf.Utf8("GET")))
  }

  override def put(request: Request, path: String): Response = {
    Response(request.version, Status.Ok, Reader.fromBuf(Buf.Utf8("PUT")))
  }

  override def post(request: Request, path: String): Response = {
    Response(request.version, Status.Ok, Reader.fromBuf(Buf.Utf8("POST")))
  }

  override def delete(request: Request, path: String): Response = {
    Response(request.version, Status.Ok, Reader.fromBuf(Buf.Utf8("DELETE")))
  }

} 

//设置package包名称以及导入依赖的类
package com.github.reikje

import java.net.URL

import com.twitter.conversions.time._
import com.twitter.finagle.client.Transporter
import com.twitter.finagle.factory.TimeoutFactory
import com.twitter.finagle.http.Request
import com.twitter.finagle.service.FailFastFactory.FailFast
import com.twitter.finagle.{Http, param}
import com.twitter.io.Buf
import com.twitter.util.Await

object Test {
  def main(args: Array[String]): Unit = {
    val url = new URL("https://github.com")

    println(s"Creating client using inet!${url.getHost}:443")

    val client = Http.client
      .configured(param.Label("finagle_pools"))
      .configured(TimeoutFactory.Param(10.seconds))
      .configured(Transporter.ConnectTimeout(10.seconds))
      .configured(FailFast(enabled = false))
      .withTransport.tls(hostname = url.getHost)
      .withTransport.verbose
      .withSessionPool.minSize(1)
      .withSessionPool.maxSize(2)
      .withSessionPool.maxWaiters(250)
      .newClient(s"inet!${url.getHost}:443")
      .toService

    val request = Request("https://github.com/twitter/finagle")
    val response = Await.result(client(request))
    println(new String(Buf.ByteArray.Owned.extract(response.content), "UTF-8"))
  }
} 

//设置package包名称以及导入依赖的类
package com.twitter.finagle.redis.server

import com.twitter.finagle.Service
import com.twitter.finagle.redis.server.runner.{CommandRunner, Store}
import com.twitter.io.Buf
import com.twitter.util.Future
import com.twitter.concurrent.AsyncMutex
import com.twitter.finagle.redis.server.protocol.{Command, CommandParser}
import com.twitter.io.Buf.ByteArray

class RedisService extends Service[List[Buf], Buf] {
  private var store: Store = Store()
  private val mutex = new AsyncMutex()
  override def apply(request: List[Buf]): Future[Buf] = {
    val parsedCmd: Command = CommandParser(request)
    val sync = mutex.acquireAndRunSync {
      val (reply, newStore) = CommandRunner.run(parsedCmd, store)
      store = newStore
      reply
    }
    sync.map(reply => ByteArray.Owned(reply.decode))
  }
} 

//设置package包名称以及导入依赖的类
package com.twitter.finagle.redis.server.protocol

import com.twitter.finagle.Failure
import com.twitter.finagle.netty3.BufChannelBuffer
import com.twitter.io.Buf
import com.twitter.io.Buf.ByteArray
import org.jboss.netty.channel.{ChannelHandlerContext, Channels, MessageEvent, SimpleChannelHandler}

import scala.collection.JavaConversions._

class RedisCodec extends SimpleChannelHandler {
  override def writeRequested(ctx: ChannelHandlerContext, e: MessageEvent): Unit =
    e.getMessage match {
      case b: Buf => Channels.write(ctx, e.getFuture, BufChannelBuffer(b))
      case typ => e.getFuture.setFailure(Failure(
        s"unexpected type ${typ.getClass.getSimpleName} when encoding to ChannelBuffer"))
    }

  override def messageReceived(ctx: ChannelHandlerContext, e: MessageEvent): Unit =
    e.getMessage match {
      case frame: RedisFrame =>
        val message: List[Buf] = frame.getParts.toList.map(ByteArray.Owned.apply)
        Channels.fireMessageReceived(ctx, message)
      case typ => Channels.fireExceptionCaught(ctx, Failure(
        s"unexpected type ${typ.getClass.getSimpleName} when encoding to Buf"))
    }
} 

//设置package包名称以及导入依赖的类
package com.redbubble.hawk

import java.net.URI

import com.redbubble.hawk.HawkAuthenticate.parseRawRequestAuthHeader
import com.redbubble.hawk.params._
import com.redbubble.hawk.validate.RequestAuthorisationHeader
import com.twitter.finagle.http.Request
import com.twitter.io.Buf
import com.twitter.util.Try
import mouse.all._

object RequestContextBuilder {
  def buildContext(request: Request): Option[ValidatableRequestContext] =
    for {
      header <- parseAuthHeader(request)
      method <- HttpMethod.httpMethod(request.method.toString())
      requestUri <- Try(new URI(request.uri)).toOption
    } yield {
      val host = request.host.map(Host(_)).getOrElse(Host.UnknownHost)
      val port = Port(requestUri.getPort)
      val path = UriPath(requestUri.getRawPath)
      val pc = methodDependantPayloadContext(method, request.contentType, request.content)
      ValidatableRequestContext(RequestContext(method, host, port, path, pc), header)
    }

  private def parseAuthHeader(request: Request): Option[RequestAuthorisationHeader] =
    request.headerMap.get(AuthorisationHttpHeader).flatMap(s => parseRawRequestAuthHeader(RawAuthenticationHeader(s)))

  private def methodDependantPayloadContext(method: HttpMethod, contentType: Option[String], content: Buf): Option[PayloadContext] =
    List(Put, Post, Patch).contains(method).option(payloadContext(contentType, content))

  private def payloadContext(contentType: Option[String], content: Buf): PayloadContext = {
    val ct = contentType.map(ContentType(_)).getOrElse(ContentType.UnknownContentType)
    PayloadContext(ct, bufToBytes(content))
  }

  private def bufToBytes(b: Buf): Array[Byte] = {
    val output = new Array[Byte](b.length)
    b.write(output, 0)
    output
  }
} 

//设置package包名称以及导入依赖的类
package com.twitter.finagle.mysql.transport

import com.twitter.io.Buf

object Packet {
  val HeaderSize = 0x04
  val OkByte     = 0x00.toByte
  val ErrorByte  = 0xFF.toByte
  val EofByte    = 0xFE.toByte

  val MaxBodySize = 0xffffff

  def fromBuf(buf: Buf): Packet = {
    val br = MysqlBuf.reader(buf)

    val size = br.readUnsignedMediumLE()
    val seq = br.readUnsignedByte()
    val body = br.readAll()
    if (size != body.length) {
      throw new IllegalStateException(
        s"Bad Packet size. Expected: $size, actual ${body.length}")
    }
    Packet(seq, body)
  }
}


  def size: Int = body.length

  def toBuf: Buf = {
    val bw = MysqlBuf.writer(new Array[Byte](Packet.HeaderSize))
    bw.writeMediumLE(size)
    bw.writeByte(seq)
    bw.owned().concat(body)
  }
} 

//设置package包名称以及导入依赖的类
package com.twitter.finagle.mysql.transport

import com.twitter.io.Buf
import org.jboss.netty.buffer.ChannelBuffers
import org.jboss.netty.channel.{Channel, ChannelHandlerContext}
import org.junit.runner.RunWith
import org.scalatest.FunSuite
import org.scalatest.junit.JUnitRunner
import org.scalatest.mock.MockitoSugar

@RunWith(classOf[JUnitRunner])
class PacketFrameDecoderTest extends FunSuite with MockitoSugar {
  val ctx = mock[ChannelHandlerContext]
  val c = mock[Channel]
  val frameDecoder = new PacketFrameDecoder

  test("ignore incomplete packets") {
    val partial = Array[Byte](0x05, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03)
    val result = frameDecoder.decode(ctx, c, ChannelBuffers.wrappedBuffer(partial))
    assert(result === null)
  }

  test("decode complete packets") {
    val complete = Array[Byte](0x02, 0x00, 0x00, 0x01, 0x01, 0x02)
    val result = frameDecoder.decode(ctx, c, ChannelBuffers.wrappedBuffer(complete))
    assert(result != null)
    assert(result.size == 2)
    assert(result.seq == 1)
    assert(Buf.ByteArray.Owned.extract(result.body) === Array[Byte](0x01, 0x02))
  }

  test("16Mbyte packets") {
    val ff = (-1).toByte
    val frame: Array[Byte] = Array[Byte](ff, ff, ff, 0x01) ++ Array.fill[Byte](0xffffff)(0x00)
    val result = frameDecoder.decode(ctx, c, ChannelBuffers.wrappedBuffer(frame))
    assert(result != null)
    assert(result.size == 16777215)
    assert(result.seq == 1)
  }
} 

//设置package包名称以及导入依赖的类
package com.twitter.finagle.mysql.transport

import com.twitter.io.Buf
import org.junit.runner.RunWith
import org.scalatest.FunSuite
import org.scalatest.junit.JUnitRunner

@RunWith(classOf[JUnitRunner])
class PacketTest extends FunSuite {
 val seq = 2.toShort
 val bytes = Array[Byte](0x01, 0x02, 0x03, 0x04)
 val body = Buf.ByteArray.Owned(bytes)
 val packet = Packet(seq, body)

 test("Encode a Packet") {
   val br = MysqlBuf.reader(packet.toBuf)
   assert(bytes.size == br.readMediumLE())
   assert(seq == br.readByte())
   assert(bytes === br.take(br.remaining))
 }
} 

//设置package包名称以及导入依赖的类
package com.twitter.finagle.thrift

import com.twitter.finagle.context.Contexts
import com.twitter.util.{Return, Throw}
import com.twitter.io.Buf

case class ClientId(name: String) {
  
object ClientId {
  // As a matter of legacy, we need to support the notion of
  // an empty client id. Old version of contexts could serialize
  // the absence of a client id with an empty buffer.
  private[finagle] val clientIdCtx = new Contexts.broadcast.Key[Option[ClientId]]("com.twitter.finagle.thrift.ClientIdContext") {
    def marshal(clientId: Option[ClientId]): Buf = clientId match {
      case None => Buf.Empty
      case Some(ClientId(name)) => Buf.Utf8(name)
    }

    def tryUnmarshal(buf: Buf) = buf match {
      case buf if buf.isEmpty => Return.None
      case Buf.Utf8(name) => Return(Some(ClientId(name)))
      case invalid => Throw(new IllegalArgumentException("client id not a utf8 string"))
    }
  }

  private[this] val NoClientFn: () => Option[ClientId] = () => None

  def current: Option[ClientId] =
    Contexts.broadcast.getOrElse(clientIdCtx, NoClientFn)

  private[finagle] def let[R](clientId: ClientId)(f: => R): R =
    Contexts.broadcast.let(clientIdCtx, Some(clientId))(f)

  private[finagle] def let[R](clientId: Option[ClientId])(f: => R): R = {
    clientId match {
      case Some(id) => Contexts.broadcast.let(clientIdCtx, Some(id))(f)
      case None => Contexts.broadcast.letClear(clientIdCtx)(f)
    }
  }
} 

//设置package包名称以及导入依赖的类
package com.twitter.finagle.context

import com.twitter.finagle.util.{BufReader, BufWriter}
import com.twitter.io.Buf
import com.twitter.util.{Return, Throw, Try}


private[finagle] case class Retries(val retries: Int)

private[finagle] object Retries
  extends Contexts.broadcast.Key[Retries]("com.twitter.finagle.Retries")
{

  def current: Option[Retries] =
    Contexts.broadcast.get(Retries)

  override def marshal(retries: Retries): Buf = {
    val bw: BufWriter = BufWriter.fixed(4)
    bw.writeIntBE(retries.retries)
    bw.owned()
  }

  override def tryUnmarshal(buf: Buf): Try[Retries] = {
    if (buf.length != 4) {
      Throw(new IllegalArgumentException(
        s"Could not extract Retries from Buf. Length ${buf.length} but required 4"))
    } else {
      val retries: Int = BufReader(buf).readIntBE()
      Return(Retries(retries))
    }
  }
} 

//设置package包名称以及导入依赖的类
package com.twitter.finagle.netty3.codec

import com.twitter.finagle.Failure
import com.twitter.finagle.framer.Framer
import com.twitter.io.Buf
import org.jboss.netty.channel._


private[finagle] class FrameDecoderHandler(
  framer: Framer) extends SimpleChannelUpstreamHandler {

  override def messageReceived(ctx: ChannelHandlerContext, e: MessageEvent): Unit =
    e.getMessage match {
      case buf: Buf =>
        val frames: IndexedSeq[Buf] = framer(buf)
        var i = 0
        while (i < frames.length) {
          Channels.fireMessageReceived(ctx, frames(i))
          i += 1
        }
      case msg => Channels.fireExceptionCaught(ctx, Failure(
        "unexpected type when framing Buf." +
          s"Expected Buf, got ${msg.getClass.getSimpleName}."))
    }
} 

//设置package包名称以及导入依赖的类
package com.twitter.finagle.netty3.codec

import com.twitter.finagle.Failure
import com.twitter.finagle.netty3.{BufChannelBuffer, ChannelBufferBuf}
import com.twitter.io.Buf
import org.jboss.netty.buffer.ChannelBuffer
import org.jboss.netty.channel._


private[finagle] class BufCodec extends SimpleChannelHandler {
  override def writeRequested(ctx: ChannelHandlerContext, e: MessageEvent): Unit =
    e.getMessage match {
      case b: Buf => Channels.write(ctx, e.getFuture, BufChannelBuffer(b))
      case typ => e.getFuture.setFailure(Failure(
        s"unexpected type ${typ.getClass.getSimpleName} when encoding to ChannelBuffer"))
    }

  override def messageReceived(ctx: ChannelHandlerContext, e: MessageEvent): Unit =
    e.getMessage match {
      case cb: ChannelBuffer => Channels.fireMessageReceived(ctx, ChannelBufferBuf.Owned(cb))
      case typ => Channels.fireExceptionCaught(ctx, Failure(
        s"unexpected type ${typ.getClass.getSimpleName} when encoding to Buf"))
    }
} 

//设置package包名称以及导入依赖的类
package com.twitter.finagle.netty3.codec

import com.twitter.finagle.Failure
import com.twitter.io.{Buf, Charsets}
import org.jboss.netty.buffer.{ChannelBuffer, ChannelBuffers}
import org.jboss.netty.handler.codec.embedder.{CodecEmbedderException, DecoderEmbedder, EncoderEmbedder}
import org.junit.runner.RunWith
import org.scalatest.FunSuite
import org.scalatest.junit.JUnitRunner

@RunWith(classOf[JUnitRunner])
class BufCodecTest extends FunSuite {
  test("decode") {
    val de = new DecoderEmbedder[Buf](new BufCodec)

    de.offer(ChannelBuffers.wrappedBuffer("hello".getBytes(Charsets.Utf8)))
    assert(de.size() == 1)
    assert(de.poll() == Buf.Utf8("hello"))
    assert(de.size() == 0)

    val exc = intercept[CodecEmbedderException] { de.offer(new Object) }
    assert(exc.getCause.isInstanceOf[Failure])
  }

  test("encode") {
    val ee = new EncoderEmbedder[ChannelBuffer](new BufCodec)
    ee.offer(Buf.Utf8("hello"))
    assert(ee.size == 1)
    val cb = ee.poll()
    assert(cb.toString(Charsets.Utf8) == "hello")
    assert(ee.size == 0)

    val cf = ee.getPipeline.getChannel.write(new Object)
    assert(cf.getCause.isInstanceOf[Failure])
  }
} 

//设置package包名称以及导入依赖的类
package com.twitter.finagle.http

import com.twitter.finagle.netty3.ChannelBufferBuf
import com.twitter.finagle.transport.Transport
import com.twitter.io.{Buf, Reader}
import com.twitter.util.{Future, Return}
import org.jboss.netty.handler.codec.http.{HttpChunk, DefaultHttpChunk}

private[http] object ReaderUtils {
  
  def streamChunks(
    trans: Transport[Any, Any],
    r: Reader,
    // TODO Find a better number for bufSize, e.g. 32KiB - Buf overhead
    bufSize: Int = Int.MaxValue
  ): Future[Unit] = {
    r.read(bufSize) flatMap {
      case None =>
        trans.write(HttpChunk.LAST_CHUNK)
      case Some(buf) =>
        trans.write(chunkOfBuf(buf)) transform {
          case Return(_) => streamChunks(trans, r, bufSize)
          case _ => Future(r.discard())
        }
    }
  }
} 

//设置package包名称以及导入依赖的类
package com.twitter.finagle.mux

import com.twitter.concurrent.AsyncQueue
import com.twitter.conversions.time._
import com.twitter.finagle.mux.transport.Message
import com.twitter.finagle.stats.NullStatsReceiver
import com.twitter.finagle.transport.QueueTransport
import com.twitter.finagle.{Path, Service}
import com.twitter.io.Buf
import com.twitter.util.{Await, Promise}
import org.junit.runner.RunWith
import org.scalatest.FunSuite
import org.scalatest.concurrent.{Eventually, IntegrationPatience}
import org.scalatest.junit.JUnitRunner

@RunWith(classOf[JUnitRunner])
class DispatcherTest extends FunSuite
  with Eventually
  with IntegrationPatience {

  test("Discard request properly sent") {
    @volatile var handled = false
    val p = Promise[Response]()
    p.setInterruptHandler { case t: Throwable =>
      handled = true
    }

    val svc = Service.mk[Request, Response](_ => p)

    val q0, q1 = new AsyncQueue[Message]
    val clientTrans = new QueueTransport[Message, Message](q0, q1)
    val serverTrans = new QueueTransport[Message, Message](q1, q0)

    val server = ServerDispatcher.newRequestResponse(serverTrans, svc)
    val session = new ClientSession(
      clientTrans, FailureDetector.NullConfig, "test", NullStatsReceiver)
    val client = ClientDispatcher.newRequestResponse(session)

    val f = client(Request(Path.empty, Buf.Empty))
    assert(!f.isDefined)
    assert(!p.isDefined)
    f.raise(new Exception())
    eventually { assert(handled) }
    Await.ready(server.close().join(client.close()), 5.seconds)
  }
} 

//设置package包名称以及导入依赖的类
package com.twitter.finagle.mux.transport

import com.twitter.finagle.Failure
import com.twitter.finagle.util.BufWriter
import com.twitter.io.Buf
import org.junit.runner.RunWith
import org.scalatest.FunSuite
import org.scalatest.junit.JUnitRunner

@RunWith(classOf[JUnitRunner])
class MuxFailureTest extends FunSuite {

  test("Flag values") {
    assert(MuxFailure.Restartable == 1L << 0)
    assert(MuxFailure.Rejected == 1L << 1)
    assert(MuxFailure.NonRetryable == 1L << 2)
  }

  test("convert flags with c.t.f.Failure") {
    val flagTests = Seq(
      (Failure.Restartable|Failure.Rejected, MuxFailure.Restartable|MuxFailure.Rejected),
      (Failure.NonRetryable, MuxFailure.NonRetryable),
      (0L, 0L)
    )

    flagTests.foreach {
      case (finagle, mux) =>
        assert(MuxFailure(mux).finagleFlags == finagle)
        assert(MuxFailure.fromThrow(Failure(":(", finagle)).flags == mux)
    }
  }

  test("Convert to & from context pairs") {
    val muxFail = MuxFailure(MuxFailure.NonRetryable)

    val expectedContext = Seq(
      (Buf.Utf8("MuxFailure"), BufWriter.fixed(8).writeLongBE(MuxFailure.NonRetryable).owned())
    )

    assert(muxFail.contexts.equals(expectedContext))

    // Round trip
    assert(MuxFailure.fromContexts(muxFail.contexts) == Some(muxFail))

    // Special case - No relevant info, so no need to pass context.
    assert(MuxFailure.Empty.contexts == Nil)
  }
} 

//设置package包名称以及导入依赖的类
package com.twitter.finagle.mux

import com.twitter.conversions.time._
import com.twitter.finagle._
import com.twitter.io.Buf
import com.twitter.util._
import org.junit.runner.RunWith
import org.scalatest.junit.JUnitRunner
import org.scalatest.FunSuite

@RunWith(classOf[JUnitRunner])
class CrossVersionEndToEndTest extends FunSuite {
  test("various netty implementations") {
    val muxEchoService = Service.mk[Request, Response] { req =>
      Future.value(Response(req.body))
    }

    val baseServer: Mux.Server = Mux.server
    val servers: Seq[Mux.Server] = Seq(
      baseServer.configured(Mux.param.MuxImpl.Netty3),
      baseServer.configured(Mux.param.MuxImpl.Netty4))

    val baseClient: Mux.Client = Mux.client
    val clients: Seq[Mux.Client] = Seq(
      baseClient.configured(Mux.param.MuxImpl.Netty3),
      baseClient.configured(Mux.param.MuxImpl.Netty4))

    for (server <- servers; client <- clients) {
      val srv = server.serve("localhost:*", muxEchoService)
      val clnt = client.newService(srv)

      val req = clnt(Request(Path.empty, Buf.Utf8("hello world")))
      assert(Await.result(req, 5.seconds) == Response(Buf.Utf8("hello world")))

      Await.result(srv.close(), 5.seconds)
      Await.result(clnt.close(), 5.seconds)
    }
  }

  test("Mux object uses netty3 impl by default") {
    assert(Mux.client.params[Mux.param.MuxImpl].transporter(Stack.Params.empty).toString ==
      "Netty3Transporter")
    assert(Mux.server.params[Mux.param.MuxImpl].listener(Stack.Params.empty).toString ==
      "Netty3Listener")
  }
}