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

import java.nio.charset.StandardCharsets
import java.util.UUID
import java.net.URLEncoder
import com.twitter.finagle.http.Request
import shapeless.tag._
import cats.implicits._
import com.lookout.ratelimitingfilter.models._


object RequestNormalization {
  def apply(
    serviceLookup: Request => Option[String @@ ServiceName],
    claimLookup: Request => Option[(UUID @@ EntClaim, UUID @@ SubClaim)],
    request: Request
  ): List[String] = {
    val method = request.method
    val path = encodePath(request.path)
    val serviceBuckets: Option[List[String]] = serviceLookup(request).map {
      serviceName => s"$method::$serviceName" :: s"$method::$path::$serviceName" :: Nil
    }
    val idBuckets: Option[List[String]] = claimLookup(request).map {
      case (entUuid, subUuid) =>
        s"$method::$path::$entUuid" :: s"$method::$path::$subUuid" :: Nil
    }

    (serviceBuckets |+| idBuckets).getOrElse(Nil)
  }

  def encodePath(path: String): String =
    URLEncoder.encode(path, StandardCharsets.UTF_8.toString).toLowerCase
} 

//设置package包名称以及导入依赖的类
package placeholder.base

import java.net.InetSocketAddress

import com.twitter.finagle
import com.twitter.finagle.Service
import com.twitter.finagle.http.{Request, Response}
import com.twitter.util.Future
import org.scalatest._
import placeholder.Main

import scala.concurrent.Await
import scala.concurrent.duration._

trait IntegrationTestBase extends FeatureSpec with GivenWhenThen with Matchers with BeforeAndAfterAll {
  val server = Main

  var serverAddress: InetSocketAddress = _
  var client: Service[Request, Response] = _
  var requestHost: String = _

  server.main(Array())

  override def beforeAll(): Unit = {
    serverAddress = Await.result(server.getServerAddress, 10.seconds)
    requestHost = s"localhost:${serverAddress.getPort.toString}"
    client = finagle.Http.newService(requestHost)
  }

  def performRequest(request: Request): Future[Response] = {
    request.host = requestHost
    client(request)
  }
} 

//设置package包名称以及导入依赖的类
package app.filter

import com.twitter.finagle.filter.LogFormatter
import com.twitter.finagle.http.Status.InternalServerError
import com.twitter.finagle.http.filter.CommonLogFormatter
import com.twitter.finagle.http.{ Request, Response }
import com.twitter.finagle.{ Service, SimpleFilter }
import com.twitter.logging.Logger
import com.twitter.util._


abstract class RequestLoggingFilter[REQ <: Request](val formatter: LogFormatter[REQ, Response])
  extends SimpleFilter[REQ, Response] {

  private val log = Logger.get(getClass)

  final def apply(request: REQ, service: Service[REQ, Response]): Future[Response] = {
    //log.info(s">>> RAW REQUEST: '${request.getContentString()}'")
    val elapsed = Stopwatch.start()
    val future = service(request)
    future.respond {
      case Return(response) => logSuccess(elapsed(), request, response)
      case Throw(error)     => logException(elapsed(), request, error)
    }
    future
  }

  final def logSuccess(replyTime: Duration, request: REQ, response: Response): Unit = {
    val line = formatter.format(request, response, replyTime)
    log.info(line)
  }

  final def logException(duration: Duration, request: REQ, error: Throwable): Unit = {
    val response = Response(request.version, InternalServerError)
    val line = formatter.format(request, response, duration)
    log.info(line)
  }
}

object RequestLoggingFilter extends RequestLoggingFilter[Request](new CommonLogFormatter) 

//设置package包名称以及导入依赖的类
package app.v1.handler

import com.twitter.finagle.http.{ Request, Response, Status, Version }
import com.twitter.logging.Logger
import com.twitter.util.Future
import io.finch.Error.{ NotParsed, NotPresent, NotValid }
import io.finch._

trait ErrorHandler {

  private val log = Logger.get(getClass)

  def apiErrorHandler: PartialFunction[Throwable, Output[Nothing]] = {
    case e: NotPresent => BadRequest(e)
    case e: NotParsed  => BadRequest(e)
    case e: NotValid   => BadRequest(e)
    case e: Exception  => InternalServerError(e)
  }

  def topLevelErrorHandler[REQUEST <: Request](request: REQUEST, encoder: Encode[Throwable]): PartialFunction[Throwable, Future[Response]] = {
    case t: Throwable => unhandledException(request, t, encoder)
  }

  private def unhandledException[REQUEST <: Request](request: REQUEST, t: Throwable, encoder: Encode[Throwable]): Future[Response] = {
    try {
      log.info(s"Unhandled exception on URI ${request.uri} with message $t")
      Future.value(Response(Version.Http11, Status.InternalServerError))
    } catch {
      case e: Throwable => {
        log.error(s"Unable to log unhandled exception: $e")
        throw e
      }
    }
  }
} 

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

import com.twitter.finagle.http.{Request, Response}
import com.twitter.finagle.{Failure, Service, SimpleFilter, RefusedByRateLimiter}
import com.twitter.util.Future
import com.twitter.logging.Logger


case class HandleRefusedByRateLimiterFilter() extends SimpleFilter[Request, Response] {
  val LOG = Logger.get(getClass)

  def apply(request: Request, service: Service[Request, Response]): Future[Response] = Future {
    service(request) handle {
      case _: RefusedByRateLimiter => {
        val rateLimitedMessage = s"Request is rate limited: ${request.encodeString()}"
        LOG.info(rateLimitedMessage)
        RefusedByRateLimiterError(rateLimitedMessage).toResponse
      }
    }
  }.flatMap(identity _)
} 

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

import java.util.UUID
import com.twitter.finagle.http.{Request}
import com.twitter.util.{Future}
import com.twitter.logging.Logger
import shapeless.tag._
import com.lookout.ratelimitingfilter.models._


case class LookoutRateLimitingStrategy(
  serviceLookup: Request => Option[String @@ ServiceName],
  claimLookup: Request => Option[(UUID @@ EntClaim, UUID @@ SubClaim)],
  rulesLookup: () => List[RateLimitRule],
  processRule: RateLimitRule => Boolean
) {
  val LOG = Logger.get(getClass)

  def apply(request: Request): Future[Boolean] = {
    val normalizedRequests = RequestNormalization(serviceLookup, claimLookup, request)
    val matchedRules = RateLimitRuleMatcher(rulesLookup, normalizedRequests)
    val underThreshold = try {
      matchedRules.map(processRule).reduce(_ && _)
    } catch {
      case e: RedisError => {
        LOG.info(s"Redis error. Rate limiting is switched off. ${e.getMessage}")
        true
      }
    }
    Future.value(underThreshold)
  }
} 

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

import com.twitter.finagle.http.{Request, Status}
import org.specs2.{Specification, ScalaCheck}
import io.circe.syntax._
import io.circe.jawn._
import com.lookout.ratelimitingfilter.models._

class RefusedByRateLimiterErrorSpec extends Specification with ScalaCheck with Arbitraries {
  def is = s2"""
    RefusedByRateLimiterError object
      it should not lose data on roundtrips to JSON $dataIntegrity
      it should contain a `message` field           $messageField
      it should create a response with 429 status   $statusCode
  """

  def fields(error: RefusedByRateLimiterError): Seq[String] =
    error.asJson.asObject.toList.flatMap(_.fields)

  def dataIntegrity = prop {
    (error: RefusedByRateLimiterError) => {
      (decode[RefusedByRateLimiterError](error.asJson.noSpaces)) must_== Right(error)
    }
  }

  def messageField = prop {
    (error: RefusedByRateLimiterError) => {
      fields(error) must contain("message")
    }
  }

  def statusCode = prop {
    (error: RefusedByRateLimiterError) => {
      error.toResponse.status must_== Status.TooManyRequests
    }
  }
} 

//设置package包名称以及导入依赖的类
package featherbed

import java.net.URL

import com.twitter.finagle.{Filter, Http}
import com.twitter.finagle.http.{Request, Response}
import org.scalamock.matchers.Matcher
import org.scalamock.scalatest.MockFactory

package object fixture {
  private[fixture] class MockClient (
    baseUrl: URL,
    filter: Filter[Request, Response, Request, Response]
  ) extends Client(baseUrl) {
    override def clientTransform(c: Http.Client) = c.filtered(filter)
  }

  trait ClientTest { self: MockFactory =>
    class TransportRequestMatcher(f: Request => Unit) extends Matcher[Any] {
      override def canEqual(x: Any) = x match {
        case x: Request => true
        case _ => false
      }
      override def safeEquals(that: Any): Boolean = that match {
        case x: Request => f(x); true
        case _ => false
      }
    }

    def request(f: Request => Unit): TransportRequestMatcher = new TransportRequestMatcher(f)

    def mockClient(url: String, filter: Filter[Request, Response, Request, Response]): Client =
      new MockClient(new URL(url), filter)
  }
} 

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

import com.twitter.finagle.http.Request
import com.twitter.finatra.http.Controller

class QwebmonController(drivers: Map[String, DbDriver]) extends Controller {

  get("/refresh/:target") { r: Request =>
    val targetName = r.getParam("target")
    drivers.get(targetName).map { driver =>
      val runningQueries = driver.runningQueries
      DbStatus(runningQueries, runningQueries.length)
    }.getOrElse(response.badRequest(s"invalid target supplied: $targetName"))
  }

  get("/") { r: Request =>
    response.ok.file("/index.html")
  }

}

case class DbStatus(runningQueries: Seq[RunningQuery], runningQueryCount: Int) 

//设置package包名称以及导入依赖的类
package com.bob.scalatour.twitters

import com.twitter.finagle.transport.Transport
import com.twitter.finagle.{Http, Service}
import com.twitter.finagle.http.{Method, Response, Request}
import com.twitter.finagle.loadbalancer.{Balancers, LoadBalancerFactory}
import com.twitter.util.{Await => twitterAwait, Monitor}

object HttpTips {

  def main(args: Array[String]) {
    val balancer: LoadBalancerFactory = Balancers.heap()

    val monitor: Monitor = new Monitor {
      override def handle(exc: Throwable): Boolean = {
        // do sth with the exception
        true
      }
    }

    val client: Service[Request, Response] = Http.client
      .withMonitor(monitor)
      .withLoadBalancer(balancer)
      // It’s important to disable Fail Fast when only have one host in the replica set
      // because Finagle doesn’t have any other path to choose.
      .withSessionQualifier.noFailFast
      .configured(Transport.Options(noDelay = false, reuseAddr = false))
      .newService("172.16.40.68:8090,172.16.40.69:8090", "riskservice")

    val request = Request(Method.Get, "/calculator/users/together?userId=1234&date=2015-12-12&bbb=bbb")
    // here we should set the host header value even it is empty,otherwise it will nothing can obtain
    request.headerMap.add("host", "")
    (1 to 20).map {
      z => {
        println(s"now is the ${z} request to send")
        val response = client(request)
        twitterAwait.ready(response.map(x => println(x.contentString)))
      }
    }

    val url = Request.queryString("/calculator/users/together", Map("userId" -> "314", "date" -> "2015", "bbb" -> "bbb"))
    println(url) // url value will be: /calculator/users/together?userId=314&date=2015&bbb=bbb
    println("http invoke done")
  }
} 

//设置package包名称以及导入依赖的类
package com.bob.reservefund.scala

import com.google.inject.Inject
import com.twitter.finagle.http.{Response, Request}
import com.twitter.finatra.http.exceptions.HttpException
import com.twitter.finatra.http.exceptions.ExceptionMapper
import com.twitter.finatra.http.response.ResponseBuilder

class MExceptionMapper @Inject()(response: ResponseBuilder) extends ExceptionMapper[Exception] {

  override def toResponse(request: Request, throwable: Exception): Response = {
    throwable match {
      case e: HttpException =>
        val builder = response.status(e.statusCode)
        builder.json(
          s"""
             |{
             |  "msg": ${e.getMessage()}
              |}
          """.stripMargin)
      case _: Exception =>
        response.status(500).json( """{
                                     |      "name": "Bob",
                                     |      "age": 19
                                     |    }""")
    }
  }
} 

//设置package包名称以及导入依赖的类
package com.gilesc
package mynab
package finch

import com.gilesc.mynab.finch.endpoint.AccountEndpoints
import com.gilesc.mynab.finch.endpoint.AccountGroupEndpoints

object WebServer {
  import com.twitter.finagle.http.{Request, Response}
  import com.twitter.finagle.{Http, Service}
  import com.twitter.util.Await
  import io.circe.generic.auto._
  import io.finch._
  import io.finch.circe._

  // Endpoints
  val api: Service[Request, Response] = (
      AccountGroupEndpoints.postGroup :+:
      AccountGroupEndpoints.getGroup :+:
      AccountEndpoints.getAccount :+:
      AccountEndpoints.postAccount
    ).handle({
    case e => NotFound(new Exception(e.toString))
  }).toServiceAs[Application.Json]

  // Service Stuff
  def shutdown(): Unit = {}

  def main(args: Array[String]): Unit = {
    val server = Http.server.serve(":8080", api)
    Await.ready(server)
    shutdown()
  }
} 

//设置package包名称以及导入依赖的类
package br.com.verde.serverstats

import com.twitter.finatra.http.Controller
import com.google.inject.Inject
import com.twitter.finatra.validation._
import com.google.inject.Singleton
import com.twitter.finagle.http.Request
import java.lang.management.ManagementFactory
import java.lang.management.OperatingSystemMXBean
import java.io.File

@Singleton
class ServerStatsController @Inject() extends Controller {

  val runtime = Runtime.getRuntime

  val osBean = ManagementFactory.getOperatingSystemMXBean
  val runtimeBean = ManagementFactory.getRuntimeMXBean
  val memoryBean = ManagementFactory.getMemoryMXBean

  val megabyte = 1024 * 1024
  val second = 1000 // milisecond

  get("/serverStats") {
    request: Request =>

      val jvmTotalRam = runtime.maxMemory
      val jvmFreeRam = runtime.freeMemory
      val availableProcessors = osBean.getAvailableProcessors

      val freeSpace = File.listRoots.head.getFreeSpace

      val serverSystemLoad = osBean.getSystemLoadAverage
      val serverUptime = runtimeBean.getUptime

      val param = request.getParam("onlyRam")
      if (param == null) {
        response
          .ok
          .json(s"""{ "jvm_total_ram": "${jvmTotalRam / megabyte} Mb",
          "jvm_free_ram": "${jvmFreeRam / megabyte} Mb",
          "free_space": "${freeSpace / megabyte} Mb",
          "server_system_load": "${serverSystemLoad} %",
          "server_uptime": "${serverUptime / second} s",
          "available_processors": "${availableProcessors}" }""")
      } else {
        response
          .ok
          .json(s"""{ "jvm_total_ram": "${jvmTotalRam / megabyte} Mb",
          "jvm_free_ram": "${jvmFreeRam / megabyte} Mb" }""")
      }
  }
} 

//设置package包名称以及导入依赖的类
package io.peregrine.test

import io.peregrine.{Controller, MockApp}
import com.twitter.finagle.http.Request
import org.jboss.netty.handler.codec.http.HttpMethod
import org.scalatest.{FlatSpec, Matchers}

import scala.collection.JavaConverters._

class MockAppSpec extends FlatSpec with Matchers {
  val server = MockApp(new Controller{})

  "#toByteArray" should "directly convert String to Array[Byte]" in {
    val value = "hello world"
    server.toByteArray(value).get should be(value.getBytes)
  }

  it should "also directly convert Array[Byte] to Array[Byte]" in {
    val value = "hello world".getBytes
    server.toByteArray(value).get should be(value)
  }

  it should "convert Map[String, String] to url-encoded form data" in {
    val value = Map("hello" -> "world")
    server.toByteArray(value).get should be("hello=world".getBytes)
  }

  it should "convert util.Map[String, String] to url-encoded form data" in {
    val value = Map("hello" -> "world").asJava
    server.toByteArray(value).get should be("hello=world".getBytes)
  }

  it should "convert null to None" in {
    server.toByteArray(null) should be(None)
  }

  it should "attempt to convert other objects to a json equivalent" in {
    val sample = Sample("matt", "[email protected]")
    server.toByteArray(sample).get should be( """{"name":"matt","email":"[email protected]"}""".getBytes)
  }

  "#buildRequest" should "apply body if present" in {
    val sample = Sample("matt", "[email protected]")

    // When
    val request: Request = server.buildRequest(HttpMethod.POST, "/", body = sample)

    // Then
    request.contentString should be(MockApp.mapper.writeValueAsString(sample))
  }

  it should "not allow both params AND a non-null body in the same request" in {
    val sample = Sample("matt", "[email protected]")
    a [RuntimeException] should be thrownBy {
      server.buildRequest(HttpMethod.POST, "/", params = Map("hello" -> "world"), body = sample)
    }
  }

  case class Sample(name: String, email: String)
} 

//设置package包名称以及导入依赖的类
package $package$

import com.twitter.finagle.http.{Request, Response}
import com.twitter.finatra.http.HttpServer
import com.twitter.finatra.http.filters.{CommonFilters, LoggingMDCFilter, TraceIdMDCFilter}
import com.twitter.finatra.http.routing.HttpRouter
import $package$.controllers.MainController

object ServerMain extends Server

class Server extends HttpServer {
  override val name = "$package$ $name;format="Camel"$"

  override def configureHttp(router: HttpRouter) {
    router
      .filter[CommonFilters]
      .filter[LoggingMDCFilter[Request, Response]]
      .filter[TraceIdMDCFilter[Request, Response]]
      .add[MainController]
  }
} 

//设置package包名称以及导入依赖的类
package com.github.ikhoon.app.v1.ping

import javax.inject.Inject

import com.github.ikhoon.swagger.SimpleSwaggerController
import com.google.inject.Singleton
import com.twitter.finagle.http.Request
import com.twitter.util.Future
import com.typesafe.config.Config

case class Pong(pong: String)

@Singleton
class PingController @Inject() (config: Config) extends SimpleSwaggerController {

  {
    get("/ping") { request: Request =>
      info("ping")
      Future.value(Pong("pong"))
    }
  }
} 

//设置package包名称以及导入依赖的类
package me.kamkor.yaas.http.exceptions.json

import javax.inject.Inject

import com.twitter.finagle.http.{Request, Response, Status}
import com.twitter.finatra.http.exceptions.ExceptionMapper
import com.twitter.finatra.http.response.ResponseBuilder
import com.twitter.finatra.json.internal.caseclass.exceptions.CaseClassMappingException
import me.kamkor.yaas.http.responses.ErrorResponse

class CaseClassExceptionMapper @Inject()(
  response: ResponseBuilder
) extends ExceptionMapper[CaseClassMappingException] {

  override def toResponse(request: Request, e: CaseClassMappingException): Response = {
    // FIXME, do it properly
    val errorMessage = e.errors map (_.getMessage) mkString ("\n")

    val errorResponse =
      ErrorResponse(
        status = Status.BadRequest.code,
        message = errorMessage
      )

    response.badRequest.json(errorResponse)
  }


} 

//设置package包名称以及导入依赖的类
package me.kamkor.yaas.http.filters

import com.twitter.finagle.http.{Request, Response}
import com.twitter.finagle.{Service, SimpleFilter}
import com.twitter.util.Future
import me.kamkor.yaas.http.exceptions.ValidationException
import me.kamkor.yaas.http.filters.YaasHeadersContext._

class YaasHeadersTenantConsistentWithRouteFilter(routeParamName: String) extends SimpleFilter[Request, Response] {

  def this() = this("tenant")

  override def apply(request: Request, service: Service[Request, Response]): Future[Response] = {
    checkIfHeaderTenantConsistentWithRoute(request)
    service(request)
  }

  private def checkIfHeaderTenantConsistentWithRoute(request: Request): Unit =
    Option(request.getParam(routeParamName)) foreach { tenantRouteParam =>
      if (request.yaasHeaders.hybrisTenant != tenantRouteParam) {
        throw new ValidationException(s"'hybris-tenant' header must match route param '$routeParamName'")
      }
    }

} 

//设置package包名称以及导入依赖的类
package me.kamkor.yaas.http.filters

import com.twitter.finagle.http.{Request, Response}
import com.twitter.finagle.{Service, SimpleFilter}
import com.twitter.util.Future

object YaasHeaders {
  val HybrisTenant = "hybris-tenant"
}

case class YaasHeaders(hybrisTenant: String)

class YaasHeadersFilter extends SimpleFilter[Request, Response] {
  override def apply(request: Request, service: Service[Request, Response]): Future[Response] = {
    YaasHeadersContext.setYaasHeaders(request)
    service(request)
  }
}

// create a context, see https://twitter.github.io/finatra/user-guide/build-new-http-server/filter.html
object YaasHeadersContext {

  private val YaasHeadersField = Request.Schema.newField[YaasHeaders]

  implicit class YaasAwareContextSyntax(val request: Request) extends AnyVal {
    def yaasHeaders: YaasHeaders = request.ctx(YaasHeadersField)
  }

  private[filters] def setYaasHeaders(request: Request): Unit = {
    val hybrisTenant = request.headerMap(YaasHeaders.HybrisTenant)
    val yaasAware = YaasHeaders(hybrisTenant)
    request.ctx.update(YaasHeadersField, yaasAware)
  }

} 

//设置package包名称以及导入依赖的类
package me.kamkor.yaas.proxy

import com.github.benmanes.caffeine.cache.{Cache, Caffeine}
import com.twitter.conversions.time._
import com.twitter.finagle.http.{Request, Response}
import com.twitter.finatra.utils.FutureUtils
import com.twitter.util.Future
import me.kamkor.finatra.httpclient.HttpClient
import me.kamkor.yaas.oauth2.OAuthService
import me.kamkor.yaas.oauth2.model.{AccessToken, ClientCredentials}

object YaasProxyClient {
  def apply(oauthService: OAuthService, httpClient: HttpClient) = new YaasProxyClient(oauthService, httpClient)
}

class YaasProxyClient(oauthService: OAuthService, httpClient: HttpClient) {

  val cache: Cache[ClientCredentials, AccessToken] = Caffeine.newBuilder()
    .build()

  def execute(request: Request)(implicit clientCredentials: ClientCredentials): Future[Response] = {
    getToken(clientCredentials) flatMap { token =>
      request.authorization = token.bearerAuthorization
      httpClient.execute(request)
    }
  }

  private def getToken(credentials: ClientCredentials): Future[AccessToken] = {
    Option(cache.getIfPresent(credentials)) match {
      case Some(token) => Future.value(token)
      case None => refreshToken(credentials)
    }
  }

  private def refreshToken(credentials: ClientCredentials): Future[AccessToken] = {
    def invalidateCache(): Future[Unit] = Future(cache.invalidate(credentials))

    oauthService.getToken(credentials) map { token =>
      cache.put(credentials, token)
      val invalidateIn = token.expiresIn - Math.round((token.expiresIn * 0.2))
      FutureUtils.scheduleFuture(invalidateIn.seconds)(invalidateCache)
      token
    }
  }

}