diff --git a/finagle-core/src/main/scala/com/twitter/finagle/builder/SourceTrackingMonitor.scala b/finagle-core/src/main/scala/com/twitter/finagle/builder/SourceTrackingMonitor.scala index a527ea07ea..7c695ddf36 100644 --- a/finagle-core/src/main/scala/com/twitter/finagle/builder/SourceTrackingMonitor.scala +++ b/finagle-core/src/main/scala/com/twitter/finagle/builder/SourceTrackingMonitor.scala @@ -25,7 +25,7 @@ class SourceTrackingMonitor(logger: Logger, which: String) extends Monitor { false } - private[this] def unrollCauses(exc: Throwable, res: Seq[String] = Seq()): Seq[String] = exc match { + private[this] def unrollCauses(exc: Throwable, res: Seq[String] = Nil): Seq[String] = exc match { case null => res.reverse case se: SourcedException => unrollCauses(se.getCause, se.serviceName +: res) case fail: Failure => fail.getSource(Failure.Source.Service) match { diff --git a/finagle-core/src/main/scala/com/twitter/finagle/socks/SocksConnectHandler.scala b/finagle-core/src/main/scala/com/twitter/finagle/socks/SocksConnectHandler.scala index 83de7d6082..f1f650172b 100644 --- a/finagle-core/src/main/scala/com/twitter/finagle/socks/SocksConnectHandler.scala +++ b/finagle-core/src/main/scala/com/twitter/finagle/socks/SocksConnectHandler.scala @@ -86,7 +86,7 @@ class SocksConnectHandler( private[this] def writeInit(ctx: ChannelHandlerContext) { val buf = ChannelBuffers.dynamicBuffer(1024) buf.writeByte(Version5) - buf.writeByte(supportedTypes.size.toByte) + buf.writeByte(supportedTypes.length.toByte) buf.writeBytes(supportedTypes) write(ctx, buf) @@ -117,7 +117,7 @@ class SocksConnectHandler( case _ => // unresolved host buf.writeByte(HostnameIndicator) val hostnameBytes = addr.getHostName.getBytes(Charsets.UsAscii) - buf.writeByte(hostnameBytes.size) + buf.writeByte(hostnameBytes.length) buf.writeBytes(hostnameBytes) } @@ -132,11 +132,11 @@ class SocksConnectHandler( // RFC does not specify an encoding. Assume UTF8 val usernameBytes = username.getBytes(Charsets.Utf8) - buf.writeByte(usernameBytes.size.toByte) + buf.writeByte(usernameBytes.length.toByte) buf.writeBytes(usernameBytes) val passBytes = pass.getBytes(Charsets.Utf8) - buf.writeByte(passBytes.size.toByte) + buf.writeByte(passBytes.length.toByte) buf.writeBytes(passBytes) write(ctx, buf) diff --git a/finagle-core/src/main/scala/com/twitter/finagle/stats/SummarizingStatsReceiver.scala b/finagle-core/src/main/scala/com/twitter/finagle/stats/SummarizingStatsReceiver.scala index 760b3a2d6f..1c848314dc 100644 --- a/finagle-core/src/main/scala/com/twitter/finagle/stats/SummarizingStatsReceiver.scala +++ b/finagle-core/src/main/scala/com/twitter/finagle/stats/SummarizingStatsReceiver.scala @@ -8,7 +8,7 @@ package com.twitter.finagle.stats import com.google.common.util.concurrent.AtomicLongMap import com.google.common.cache.{CacheBuilder, CacheLoader} import scala.collection.JavaConverters._ -import scala.collection.mutable.{ArrayBuffer, SynchronizedBuffer} +import scala.collection.mutable.ArrayBuffer class SummarizingStatsReceiver extends StatsReceiverWithCumulativeGauges { val repr = this @@ -30,7 +30,7 @@ class SummarizingStatsReceiver extends StatsReceiverWithCumulativeGauges { } def stat(name: String*) = new Stat { - def add(value: Float) = SummarizingStatsReceiver.this.synchronized { + def add(value: Float) = SummarizingStatsReceiver.this.synchronized { stats.get(name) += value } } @@ -67,14 +67,14 @@ class SummarizingStatsReceiver extends StatsReceiverWithCumulativeGauges { val counterLines = (counterValues map { case (k, v) => (variableName(k), v.toString) }).toSeq val statLines = (statValues map { case (k, xs) => - val n = xs.size + val n = xs.length def idx(ptile: Double) = math.floor(ptile*n).toInt (variableName(k), "n=%d min=%.1f med=%.1f p90=%.1f p95=%.1f p99=%.1f p999=%.1f p9999=%.1f max=%.1f".format( n, xs(0), xs(n/2), xs(idx(.9D)), xs(idx(.95D)), xs(idx(.99D)), xs(idx(.999D)), xs(idx(.9999D)), xs(n-1))) }).toSeq lazy val tailValues = (statValues map { case (k, xs) => - val n = xs.size + val n = xs.length def slice(ptile: Double) = { val end = math.floor(ptile*n).toInt val start = math.ceil(end-((1.0-ptile)*n)).toInt diff --git a/finagle-core/src/main/scala/com/twitter/finagle/util/InetSocketAddressUtil.scala b/finagle-core/src/main/scala/com/twitter/finagle/util/InetSocketAddressUtil.scala index a6ac2c7632..30d623ae50 100644 --- a/finagle-core/src/main/scala/com/twitter/finagle/util/InetSocketAddressUtil.scala +++ b/finagle-core/src/main/scala/com/twitter/finagle/util/InetSocketAddressUtil.scala @@ -38,7 +38,7 @@ object InetSocketAddressUtil { */ def parseHostPorts(hosts: String): Seq[HostPort] = hosts split Array(' ', ',') filter (_.nonEmpty) map (_.split(":")) map { hp => - require(hp.size == 2, "You must specify host and port") + require(hp.length == 2, "You must specify host and port") hp match { case Array(host, "*") => (host, 0) case Array(host, portStr) => (host, portStr.toInt) diff --git a/finagle-core/src/main/scala/com/twitter/finagle/util/LoadService.scala b/finagle-core/src/main/scala/com/twitter/finagle/util/LoadService.scala index 519b82c4ec..5893816c89 100644 --- a/finagle-core/src/main/scala/com/twitter/finagle/util/LoadService.scala +++ b/finagle-core/src/main/scala/com/twitter/finagle/util/LoadService.scala @@ -147,10 +147,10 @@ private object ClassPath { val commentIdx = line.indexOf('#') val end = if (commentIdx != -1) commentIdx else line.length val str = line.substring(0, end).trim - if (str.isEmpty) Seq.empty else Seq(str) + if (str.isEmpty) Nil else Seq(str) } } catch { - case ex: MalformedInputException => Seq.empty /* skip malformed files (e.g. non UTF-8) */ + case ex: MalformedInputException => Nil /* skip malformed files (e.g. non UTF-8) */ } finally { source.close() } diff --git a/finagle-http/src/main/scala/com/twitter/finagle/http/codec/HttpDtab.scala b/finagle-http/src/main/scala/com/twitter/finagle/http/codec/HttpDtab.scala index afad8a6d07..56d2f2f3e3 100644 --- a/finagle-http/src/main/scala/com/twitter/finagle/http/codec/HttpDtab.scala +++ b/finagle-http/src/main/scala/com/twitter/finagle/http/codec/HttpDtab.scala @@ -69,10 +69,10 @@ object HttpDtab { } private def validHeaderPair(aKey: String, bKey: String): Boolean = - aKey.size == bKey.size && - aKey.substring(0, aKey.size-1) == bKey.substring(0, bKey.size-1) && - aKey(aKey.size-1) == 'a' && - bKey(bKey.size-1) == 'b' + aKey.length == bKey.length && + aKey.charAt(aKey.length - 1) == 'a' && + bKey.charAt(bKey.length - 1) == 'b' && + aKey.substring(0, aKey.length - 1) == bKey.substring(0, bKey.length - 1) private val EmptyReturn = Return(Dtab.empty) @@ -99,7 +99,7 @@ object HttpDtab { // TODO: now that we have a proper Dtab grammar, // should just embed this directly instead. msg.headers.set(Prefix+indexstr(i)+"-A", b64Encode(prefix.show)) - msg.headers.set(Prefix+indexstr(i)+"-B".format(i), b64Encode(dst.show)) + msg.headers.set(Prefix+indexstr(i)+"-B", b64Encode(dst.show)) } } diff --git a/finagle-http/src/main/scala/com/twitter/finagle/http/filter/Cors.scala b/finagle-http/src/main/scala/com/twitter/finagle/http/filter/Cors.scala index b583eedfad..9b74cc6921 100644 --- a/finagle-http/src/main/scala/com/twitter/finagle/http/filter/Cors.scala +++ b/finagle-http/src/main/scala/com/twitter/finagle/http/filter/Cors.scala @@ -37,7 +37,7 @@ object Cors { allowsOrigin: String => Option[String], allowsMethods: String => Option[Seq[String]], allowsHeaders: Seq[String] => Option[Seq[String]], - exposedHeaders: Seq[String] = Seq.empty, + exposedHeaders: Seq[String] = Nil, supportsCredentials: Boolean = false, maxAge: Option[Duration] = None) diff --git a/finagle-httpx/src/main/scala/com/twitter/finagle/httpx/codec/HttpDtab.scala b/finagle-httpx/src/main/scala/com/twitter/finagle/httpx/codec/HttpDtab.scala index d9bd96246c..c7847ced03 100644 --- a/finagle-httpx/src/main/scala/com/twitter/finagle/httpx/codec/HttpDtab.scala +++ b/finagle-httpx/src/main/scala/com/twitter/finagle/httpx/codec/HttpDtab.scala @@ -69,10 +69,10 @@ object HttpDtab { } private def validHeaderPair(aKey: String, bKey: String): Boolean = - aKey.size == bKey.size && - aKey.substring(0, aKey.size-1) == bKey.substring(0, bKey.size-1) && - aKey(aKey.size-1) == 'a' && - bKey(bKey.size-1) == 'b' + aKey.length == bKey.length && + aKey(aKey.length - 1) == 'a' && + bKey(bKey.length - 1) == 'b' && + aKey.substring(0, aKey.length - 1) == bKey.substring(0, bKey.length - 1) private val EmptyReturn = Return(Dtab.empty) @@ -99,7 +99,7 @@ object HttpDtab { // TODO: now that we have a proper Dtab grammar, // should just embed this directly instead. msg.headers.set(Prefix+indexstr(i)+"-A", b64Encode(prefix.show)) - msg.headers.set(Prefix+indexstr(i)+"-B".format(i), b64Encode(dst.show)) + msg.headers.set(Prefix+indexstr(i)+"-B", b64Encode(dst.show)) } } diff --git a/finagle-httpx/src/main/scala/com/twitter/finagle/httpx/filter/Cors.scala b/finagle-httpx/src/main/scala/com/twitter/finagle/httpx/filter/Cors.scala index eb405d108c..d6b6d4535a 100644 --- a/finagle-httpx/src/main/scala/com/twitter/finagle/httpx/filter/Cors.scala +++ b/finagle-httpx/src/main/scala/com/twitter/finagle/httpx/filter/Cors.scala @@ -36,7 +36,7 @@ object Cors { allowsOrigin: String => Option[String], allowsMethods: String => Option[Seq[String]], allowsHeaders: Seq[String] => Option[Seq[String]], - exposedHeaders: Seq[String] = Seq.empty, + exposedHeaders: Seq[String] = Nil, supportsCredentials: Boolean = false, maxAge: Option[Duration] = None) diff --git a/finagle-memcached/src/main/scala/com/twitter/finagle/memcached/protocol/text/client/Decoder.scala b/finagle-memcached/src/main/scala/com/twitter/finagle/memcached/protocol/text/client/Decoder.scala index a85112b88f..2b5875292c 100644 --- a/finagle-memcached/src/main/scala/com/twitter/finagle/memcached/protocol/text/client/Decoder.scala +++ b/finagle-memcached/src/main/scala/com/twitter/finagle/memcached/protocol/text/client/Decoder.scala @@ -70,7 +70,7 @@ class Decoder extends AbstractDecoder with StateMachine { final protected[memcached] def awaitData(tokens: Seq[ChannelBuffer], bytesNeeded: Int) = { state match { case AwaitingResponse() => - awaitData(Seq(), tokens, bytesNeeded) + awaitData(Nil, tokens, bytesNeeded) case AwaitingResponseOrEnd(valuesSoFar) => awaitData(valuesSoFar, tokens, bytesNeeded) } diff --git a/finagle-memcached/src/main/scala/com/twitter/finagle/memcached/util/ChannelBufferUtils.scala b/finagle-memcached/src/main/scala/com/twitter/finagle/memcached/util/ChannelBufferUtils.scala index 835264b369..e8e6a98a04 100644 --- a/finagle-memcached/src/main/scala/com/twitter/finagle/memcached/util/ChannelBufferUtils.scala +++ b/finagle-memcached/src/main/scala/com/twitter/finagle/memcached/util/ChannelBufferUtils.scala @@ -42,7 +42,7 @@ private[finagle] object ChannelBufferUtils { split(FIND_SPACE, 1) def split(delimiter: String): Seq[ChannelBuffer] = - split(stringToChannelBufferIndexFinder(delimiter), delimiter.size) + split(stringToChannelBufferIndexFinder(delimiter), delimiter.length) def split(indexFinder: ChannelBufferIndexFinder, delimiterLength: Int): Seq[ChannelBuffer] = { val tokens = new ArrayBuffer[ChannelBuffer] @@ -101,14 +101,13 @@ private[finagle] object ChannelBufferUtils { implicit def stringToChannelBufferIndexFinder(string: String): ChannelBufferIndexFinder = new ChannelBufferIndexFinder { def find(buffer: ChannelBuffer, guessedIndex: Int): Boolean = { - val array = string.toArray - var i: Int = 0 - while (i < string.size) { - if (buffer.getByte(guessedIndex + i) != array(i).toByte) + var i = 0 + while (i < string.length) { + if (buffer.getByte(guessedIndex + i) != string.charAt(i).toByte) return false i += 1 } - return true + true } } } diff --git a/finagle-memcachedx/src/main/scala/com/twitter/finagle/memcachedx/protocol/text/client/Decoder.scala b/finagle-memcachedx/src/main/scala/com/twitter/finagle/memcachedx/protocol/text/client/Decoder.scala index 37373e6c21..9f899d8c73 100644 --- a/finagle-memcachedx/src/main/scala/com/twitter/finagle/memcachedx/protocol/text/client/Decoder.scala +++ b/finagle-memcachedx/src/main/scala/com/twitter/finagle/memcachedx/protocol/text/client/Decoder.scala @@ -72,7 +72,7 @@ class Decoder extends AbstractDecoder with StateMachine { final protected[memcachedx] def awaitData(tokens: Seq[ChannelBuffer], bytesNeeded: Int) = { state match { case AwaitingResponse() => - awaitData(Seq(), tokens, bytesNeeded) + awaitData(Nil, tokens, bytesNeeded) case AwaitingResponseOrEnd(valuesSoFar) => awaitData(valuesSoFar, tokens, bytesNeeded) } diff --git a/finagle-memcachedx/src/main/scala/com/twitter/finagle/memcachedx/util/ChannelBufferUtils.scala b/finagle-memcachedx/src/main/scala/com/twitter/finagle/memcachedx/util/ChannelBufferUtils.scala index 6bdac7af9b..f4024c8f48 100644 --- a/finagle-memcachedx/src/main/scala/com/twitter/finagle/memcachedx/util/ChannelBufferUtils.scala +++ b/finagle-memcachedx/src/main/scala/com/twitter/finagle/memcachedx/util/ChannelBufferUtils.scala @@ -42,7 +42,7 @@ private[finagle] object ChannelBufferUtils { split(FIND_SPACE, 1) def split(delimiter: String): Seq[ChannelBuffer] = - split(stringToChannelBufferIndexFinder(delimiter), delimiter.size) + split(stringToChannelBufferIndexFinder(delimiter), delimiter.length) def split(indexFinder: ChannelBufferIndexFinder, delimiterLength: Int): Seq[ChannelBuffer] = { val tokens = new ArrayBuffer[ChannelBuffer] @@ -101,14 +101,13 @@ private[finagle] object ChannelBufferUtils { implicit def stringToChannelBufferIndexFinder(string: String): ChannelBufferIndexFinder = new ChannelBufferIndexFinder { def find(buffer: ChannelBuffer, guessedIndex: Int): Boolean = { - val array = string.toArray - var i: Int = 0 - while (i < string.size) { - if (buffer.getByte(guessedIndex + i) != array(i).toByte) + var i = 0 + while (i < string.length) { + if (buffer.getByte(guessedIndex + i) != string.charAt(i).toByte) return false i += 1 } - return true + true } } } diff --git a/finagle-mux/src/main/scala/com/twitter/finagle/mux/Proto.scala b/finagle-mux/src/main/scala/com/twitter/finagle/mux/Proto.scala index 1e7839cf99..c6717a0c23 100644 --- a/finagle-mux/src/main/scala/com/twitter/finagle/mux/Proto.scala +++ b/finagle-mux/src/main/scala/com/twitter/finagle/mux/Proto.scala @@ -193,7 +193,7 @@ private[finagle] object Message { } val dstbytes = if (dst.isEmpty) noBytes else dst.show.getBytes(Charsets.Utf8) - n += 2 + dstbytes.size + n += 2 + dstbytes.length n += 2 val dtabbytes = new Array[(Array[Byte], Array[Byte])](dtab.size) @@ -204,7 +204,7 @@ private[finagle] object Message { val srcbytes = src.show.getBytes(Charsets.Utf8) val treebytes = tree.show.getBytes(Charsets.Utf8) - n += srcbytes.size + 2 + treebytes.size + 2 + n += srcbytes.length + 2 + treebytes.length + 2 dtabbytes(dtabidx) = (srcbytes, treebytes) dtabidx += 1 @@ -225,16 +225,16 @@ private[finagle] object Message { seq = seq.tail } - hd.writeShort(dstbytes.size) + hd.writeShort(dstbytes.length) hd.writeBytes(dstbytes) hd.writeShort(dtab.size) dtabidx = 0 - while (dtabidx != dtabbytes.size) { + while (dtabidx != dtabbytes.length) { val (srcbytes, treebytes) = dtabbytes(dtabidx) - hd.writeShort(srcbytes.size) + hd.writeShort(srcbytes.length) hd.writeBytes(srcbytes) - hd.writeShort(treebytes.size) + hd.writeShort(treebytes.length) hd.writeBytes(treebytes) dtabidx += 1 } @@ -439,8 +439,10 @@ private[finagle] object Message { nkeys -= 1 } - val id = trace3 map { case (spanId, parentId, traceId) => - TraceId(Some(traceId), Some(parentId), spanId, None, Flags(traceFlags)) + val id = trace3 match { + case Some((spanId, parentId, traceId)) => + Some(TraceId(Some(traceId), Some(parentId), spanId, None, Flags(traceFlags))) + case None => None } Treq(tag, id, buf.slice()) @@ -449,7 +451,7 @@ private[finagle] object Message { private def decodeContexts(buf: ChannelBuffer): Seq[(ChannelBuffer, ChannelBuffer)] = { val n = buf.readUnsignedShort() if (n == 0) - return Seq.empty + return Nil val contexts = new Array[(ChannelBuffer, ChannelBuffer)](n) var i = 0 diff --git a/finagle-mux/src/main/scala/com/twitter/finagle/mux/Server.scala b/finagle-mux/src/main/scala/com/twitter/finagle/mux/Server.scala index 1c30aed549..7a28518eb6 100644 --- a/finagle-mux/src/main/scala/com/twitter/finagle/mux/Server.scala +++ b/finagle-mux/src/main/scala/com/twitter/finagle/mux/Server.scala @@ -44,7 +44,7 @@ private class Tracker[T] { private[this] val state = new AtomicInteger(1) /** - * Try to enter a transaction, returning false if the + * Try to enter a transaction, returning false if the * tracker is draining. */ @tailrec @@ -56,7 +56,7 @@ private class Tracker[T] { } /** - * Exit an entered transaction. + * Exit an entered transaction. */ @tailrec private[this] def exit(): Unit = { @@ -75,11 +75,11 @@ private class Tracker[T] { * The ordering here is important: the tag is relinquished after * `reply` is satisfied but before `process` is invoked, but is still * considered pending until `process` completes. This is because: - * (1) the tag is freed once a client receives the reply, and, since + * (1) the tag is freed once a client receives the reply, and, since * write completion is not synchronous with processing the next - * request, there is a race between acknowledging the write and + * request, there is a race between acknowledging the write and * receiving the next request from the client (which may then reuse - * the tag); (2) we can't complete draining until we've acknowledged + * the tag); (2) we can't complete draining until we've acknowledged * the write for the last request processed. */ def track(tag: Int, reply: Future[T])(process: Try[T] => Future[Unit]): Future[Unit] = { @@ -95,7 +95,7 @@ private class Tracker[T] { /** * Retrieve the value for the pending request matching `tag`. */ - def get(tag: Int): Option[Future[T]] = + def get(tag: Int): Option[Future[T]] = Option(pending.get(tag)) /** @@ -105,7 +105,7 @@ private class Tracker[T] { pending.keySet.asScala.toSet /** - * Initiate the draining protocol. After `drain` is called, future + * Initiate the draining protocol. After `drain` is called, future * requests for tracking are dropped. [[drained]] is satisified * when the number of pending requests reaches 0. */ @@ -122,7 +122,7 @@ private class Tracker[T] { * True when the tracker is in draining state. */ def isDraining: Boolean = state.get < 0 - + /** * Satisifed when the tracker has completed the draining protocol, * as described in [[drain]]. @@ -133,7 +133,7 @@ private class Tracker[T] { * Tests whether the given tag is actively tracked. */ def isTracking(tag: Int): Boolean = pending.containsKey(tag) - + /** * The number of tracked tags. */ @@ -151,21 +151,21 @@ private[twitter] object ServerDispatcher { lessor: Lessor, tracer: Tracer, statsReceiver: StatsReceiver - ): ServerDispatcher = + ): ServerDispatcher = new ServerDispatcher(trans, Processor andThen service, lessor, tracer, statsReceiver) /** - * Construct a new request-response dispatcher with a + * Construct a new request-response dispatcher with a * null lessor, tracer, and statsReceiver. */ def newRequestResponse( trans: Transport[ChannelBuffer, ChannelBuffer], service: Service[Request, Response] - ): ServerDispatcher = + ): ServerDispatcher = newRequestResponse(trans, service, Lessor.nil, NullTracer, NullStatsReceiver) val Epsilon = 1.second - + object State extends Enumeration { val Open, Draining, Closed = Value } @@ -184,22 +184,22 @@ private[twitter] class ServerDispatcher( ) extends Closable with Lessee { import Message._ import ServerDispatcher.State - + private[this] implicit val injectTimer = DefaultTimer.twitter private[this] val tracker = new Tracker[Message] private[this] val log = Logger.getLogger(getClass.getName) - - private[this] val state: AtomicReference[State.Value] = + + private[this] val state: AtomicReference[State.Value] = new AtomicReference(State.Open) @volatile private[this] var lease = Tlease.MaxLease - @volatile private[this] var curElapsed = NilStopwatch.start() + @volatile private[this] var curElapsed = NilStopwatch.start() lessor.register(this) - - private[this] def write(m: Message): Future[Unit] = + + private[this] def write(m: Message): Future[Unit] = trans.write(encode(m)) - private[this] def isAccepting: Boolean = + private[this] def isAccepting: Boolean = !tracker.isDraining && (!nackOnExpiredLease() || (lease > Duration.Zero)) private[this] def process(m: Message): Unit = m match { @@ -211,7 +211,7 @@ private[twitter] class ServerDispatcher( // we should terminate the session in this case. // // TODO: introduce uniform handling of tag tracking - // (across all request types), and also uniform handling + // (across all request types), and also uniform handling // (e.g., session termination). if (tracker.isTracking(m.tag)) { log.warning(s"Received duplicate tag ${m.tag} from client ${trans.remoteAddress}") @@ -225,7 +225,7 @@ private[twitter] class ServerDispatcher( case Return(rep) => lessor.observe(elapsed()) write(rep) - case Throw(exc) => + case Throw(exc) => log.log(Level.WARNING, s"Error processing message $m", exc) write(Rerr(m.tag, exc.toString)) } @@ -233,7 +233,7 @@ private[twitter] class ServerDispatcher( // Dispatch when !isAccepting case d: Tdispatch => write(RdispatchNack(d.tag, Nil)) - case r: Treq => + case r: Treq => write(RreqNack(r.tag)) case _: Tping => @@ -244,7 +244,7 @@ private[twitter] class ServerDispatcher( case Tdiscarded(tag, why) => tracker.get(tag) match { - case Some(reply) => + case Some(reply) => reply.raise(new ClientDiscardedRequestException(why)) case None => } @@ -259,7 +259,7 @@ private[twitter] class ServerDispatcher( Local.letClear { Trace.letTracer(tracer) { - Future.each(trans.read) { buf => + Future.each(trans.read) { buf => val save = Local.save() process(decode(buf)) Local.restore(save) @@ -278,7 +278,7 @@ private[twitter] class ServerDispatcher( service.close() lessor.unregister(this) - + state.get match { case State.Open => statsReceiver.counter("clienthangup").incr() @@ -312,7 +312,7 @@ private[twitter] class ServerDispatcher( tracker.drained.within(deadline-Time.now) before trans.close(deadline) done transform { - case Return(_) => + case Return(_) => statsReceiver.counter("drained").incr() Future.Done case Throw(_: ChannelClosedException) => @@ -349,7 +349,7 @@ private[twitter] class ServerDispatcher( * Processor handles request, dispatch, and ping messages. Request * and dispatch messages are passed onto the request-response in the * filter chain. Pings are answered immediately in the affirmative. - * + * * (This arrangement permits interpositioning other filters to modify ping * or dispatch behavior, e.g., for testing.) */ @@ -367,13 +367,13 @@ private object Processor extends Filter[Message, Message, Request, Response] { Dtab.local ++= dtab service(Request(dst, ChannelBufferBuf.Owned(bytes))) transform { case Return(rep) => - Future.value(RdispatchOk(tag, Seq.empty, BufChannelBuffer(rep.body))) + Future.value(RdispatchOk(tag, Nil, BufChannelBuffer(rep.body))) case Throw(f: Failure) if f.isFlagged(Failure.Restartable) => Future.value(RdispatchNack(tag, Nil)) case Throw(exc) => - Future.value(RdispatchError(tag, Seq.empty, exc.toString)) + Future.value(RdispatchError(tag, Nil, exc.toString)) } } } diff --git a/finagle-mysql/src/main/scala/com/twitter/finagle/mysql/Client.scala b/finagle-mysql/src/main/scala/com/twitter/finagle/mysql/Client.scala index e956015409..c8e833aefd 100644 --- a/finagle-mysql/src/main/scala/com/twitter/finagle/mysql/Client.scala +++ b/finagle-mysql/src/main/scala/com/twitter/finagle/mysql/Client.scala @@ -105,7 +105,7 @@ private[mysql] class StdClient(factory: ServiceFactory[Request, Result]) def select[T](sql: String)(f: Row => T): Future[Seq[T]] = query(sql) map { case rs: ResultSet => rs.rows.map(f) - case _ => Seq.empty + case _ => Nil } def prepare(sql: String): PreparedStatement = new PreparedStatement { diff --git a/finagle-mysql/src/main/scala/com/twitter/finagle/mysql/PreparedStatement.scala b/finagle-mysql/src/main/scala/com/twitter/finagle/mysql/PreparedStatement.scala index bd0ba16a8d..d8830b7235 100644 --- a/finagle-mysql/src/main/scala/com/twitter/finagle/mysql/PreparedStatement.scala +++ b/finagle-mysql/src/main/scala/com/twitter/finagle/mysql/PreparedStatement.scala @@ -23,6 +23,6 @@ trait PreparedStatement { def select[T](params: Any*)(f: Row => T): Future[Seq[T]] = apply(params:_*) map { case rs: ResultSet => rs.rows.map(f) - case _ => Seq.empty + case _ => Nil } } diff --git a/finagle-mysql/src/main/scala/com/twitter/finagle/mysql/Request.scala b/finagle-mysql/src/main/scala/com/twitter/finagle/mysql/Request.scala index e8b250a86e..ffc78b6319 100644 --- a/finagle-mysql/src/main/scala/com/twitter/finagle/mysql/Request.scala +++ b/finagle-mysql/src/main/scala/com/twitter/finagle/mysql/Request.scala @@ -3,7 +3,6 @@ package com.twitter.finagle.exp.mysql import com.twitter.finagle.exp.mysql.transport.{Buffer, BufferWriter, Packet} import java.security.MessageDigest import java.util.logging.Logger -import scala.annotation.tailrec object Command { val COM_NO_OP = -1.toByte // used internall by this client @@ -114,8 +113,9 @@ case class HandshakeResponse( def toPacket = { val fixedBodySize = 34 - val dbStrSize = database map { _.size + 1 } getOrElse(0) - val packetBodySize = username.getOrElse("").size + hashPassword.size + dbStrSize + fixedBodySize + val dbStrSize = database.map { _.length + 1 }.getOrElse(0) + val packetBodySize = + username.getOrElse("").length + hashPassword.length + dbStrSize + fixedBodySize val bw = BufferWriter(new Array[Byte](packetBodySize)) bw.writeInt(clientCap.mask) bw.writeInt(maxPacketSize) diff --git a/finagle-mysql/src/main/scala/com/twitter/finagle/mysql/Result.scala b/finagle-mysql/src/main/scala/com/twitter/finagle/mysql/Result.scala index 92cfd7c440..d16d184f52 100644 --- a/finagle-mysql/src/main/scala/com/twitter/finagle/mysql/Result.scala +++ b/finagle-mysql/src/main/scala/com/twitter/finagle/mysql/Result.scala @@ -259,5 +259,5 @@ object ResultSet { } case class ResultSet(fields: Seq[Field], rows: Seq[Row]) extends Result { - override def toString = "ResultSet(%d, %d)".format(fields.size, rows.size) + override def toString = s"ResultSet(${fields.size}, ${rows.size})" } diff --git a/finagle-mysql/src/main/scala/com/twitter/finagle/mysql/Type.scala b/finagle-mysql/src/main/scala/com/twitter/finagle/mysql/Type.scala index b1629b0c77..ccdf61752e 100644 --- a/finagle-mysql/src/main/scala/com/twitter/finagle/mysql/Type.scala +++ b/finagle-mysql/src/main/scala/com/twitter/finagle/mysql/Type.scala @@ -54,14 +54,14 @@ object Type { case d: java.util.Date => 12 case s: String => val bytes = s.getBytes(Charset.defaultCharset) - Buffer.sizeOfLen(bytes.size) + bytes.size + Buffer.sizeOfLen(bytes.length) + bytes.length case b: Array[Byte] => - Buffer.sizeOfLen(b.size) + b.size + Buffer.sizeOfLen(b.length) + b.length case RawValue(_, _, true, b) => - Buffer.sizeOfLen(b.size) + b.size + Buffer.sizeOfLen(b.length) + b.length case StringValue(s) => val bytes = s.getBytes(Charset.defaultCharset) - Buffer.sizeOfLen(bytes.size) + bytes.size + Buffer.sizeOfLen(bytes.length) + bytes.length case ByteValue(_) => 1 case ShortValue(_) => 2 case IntValue(_) => 4 @@ -92,9 +92,9 @@ object Type { case d: Double => Double case null => Null // blobs - case b: Array[Byte] if b.size <= 255 => TinyBlob - case b: Array[Byte] if b.size <= 65535 => Blob - case b: Array[Byte] if b.size <= 16777215 => MediumBlob + case b: Array[Byte] if b.length <= 255 => TinyBlob + case b: Array[Byte] if b.length <= 65535 => Blob + case b: Array[Byte] if b.length <= 16777215 => MediumBlob // Date and Time case t: java.sql.Timestamp => Timestamp case d: java.sql.Date => Date diff --git a/finagle-serversets/src/main/scala/com/twitter/finagle/serverset2/Entry.scala b/finagle-serversets/src/main/scala/com/twitter/finagle/serverset2/Entry.scala index ec93db7f76..e27a19c235 100644 --- a/finagle-serversets/src/main/scala/com/twitter/finagle/serverset2/Entry.scala +++ b/finagle-serversets/src/main/scala/com/twitter/finagle/serverset2/Entry.scala @@ -50,7 +50,7 @@ object Entry { if (basename startsWith EndpointPrefix) Endpoint.parseJson(json) map(_.copy(memberId=basename)) else - Seq.empty + Nil } } diff --git a/finagle-thrift/src/main/scala/com/twitter/finagle/thrift/SeqIdFilter.scala b/finagle-thrift/src/main/scala/com/twitter/finagle/thrift/SeqIdFilter.scala index 4d7dce72b1..6287884932 100644 --- a/finagle-thrift/src/main/scala/com/twitter/finagle/thrift/SeqIdFilter.scala +++ b/finagle-thrift/src/main/scala/com/twitter/finagle/thrift/SeqIdFilter.scala @@ -50,7 +50,7 @@ class SeqIdFilter extends SimpleFilter[ThriftClientRequest, Array[Byte]] { private[this] def badMsg(why: String) = Throw(new IllegalArgumentException(why)) private[this] def getAndSetId(buf: Array[Byte], newId: Int): Try[Int] = { - if (buf.size < 4) return badMsg("short header") + if (buf.length < 4) return badMsg("short header") val header = get32(buf, 0) val off = if (header < 0) { // [4]header @@ -59,7 +59,7 @@ class SeqIdFilter extends SimpleFilter[ThriftClientRequest, Array[Byte]] { // [4]seqid if ((header&VersionMask) != Version1) return badMsg("bad version %d".format(header&VersionMask)) - if (buf.size < 8) return badMsg("short name size") + if (buf.length < 8) return badMsg("short name size") 4+4+get32(buf, 4) } else { // [4]n @@ -69,7 +69,7 @@ class SeqIdFilter extends SimpleFilter[ThriftClientRequest, Array[Byte]] { 4+header+1 } - if (buf.size < off+4) return badMsg("short buffer") + if (buf.length < off+4) return badMsg("short buffer") val currentId = get32(buf, off) put32(buf, off, newId) diff --git a/finagle-thriftmux/src/main/scala/com/twitter/finagle/thriftmux/Netty3.scala b/finagle-thriftmux/src/main/scala/com/twitter/finagle/thriftmux/Netty3.scala index df3ea28251..149645ce59 100644 --- a/finagle-thriftmux/src/main/scala/com/twitter/finagle/thriftmux/Netty3.scala +++ b/finagle-thriftmux/src/main/scala/com/twitter/finagle/thriftmux/Netty3.scala @@ -56,17 +56,21 @@ private[finagle] class PipelineFactory( ) val richHeader = new RichRequestHeader(header) - val contextBuf = mutable.ArrayBuffer.empty[(ChannelBuffer, ChannelBuffer)] + val contextBuf = + new mutable.ArrayBuffer[(ChannelBuffer, ChannelBuffer)]( + 2 + (if (header.contexts == null) 0 else header.contexts.size)) contextBuf += ( BufChannelBuffer(Trace.idCtx.marshalId) -> BufChannelBuffer(Trace.idCtx.marshal(richHeader.traceId))) - richHeader.clientId foreach { clientId => - val clientIdBuf = ClientId.clientIdCtx.marshal(Some(clientId)) - contextBuf += ( - BufChannelBuffer(ClientId.clientIdCtx.marshalId) -> - BufChannelBuffer(clientIdBuf)) + richHeader.clientId match { + case Some(clientId) => + val clientIdBuf = ClientId.clientIdCtx.marshal(Some(clientId)) + contextBuf += ( + BufChannelBuffer(ClientId.clientIdCtx.marshalId) -> + BufChannelBuffer(clientIdBuf)) + case None => } if (header.contexts != null) { @@ -82,13 +86,13 @@ private[finagle] class PipelineFactory( Message.MinTag, contextBuf.toSeq, richHeader.dest, richHeader.dtab, requestBuf) } - override def messageReceived(ctx: ChannelHandlerContext, e: MessageEvent) { + override def messageReceived(ctx: ChannelHandlerContext, e: MessageEvent): Unit = { val buf = e.getMessage.asInstanceOf[ChannelBuffer] super.messageReceived(ctx, new UpstreamMessageEvent( e.getChannel, Message.encode(thriftToMux(buf)), e.getRemoteAddress)) } - override def writeRequested(ctx: ChannelHandlerContext, e: MessageEvent) { + override def writeRequested(ctx: ChannelHandlerContext, e: MessageEvent): Unit = { Message.decode(e.getMessage.asInstanceOf[ChannelBuffer]) match { case Message.RdispatchOk(_, _, rep) => super.writeRequested(ctx, @@ -142,7 +146,7 @@ private[finagle] class PipelineFactory( } private class TFramedToMux extends SimpleChannelHandler { - override def writeRequested(ctx: ChannelHandlerContext, e: MessageEvent) { + override def writeRequested(ctx: ChannelHandlerContext, e: MessageEvent): Unit = { Message.decode(e.getMessage.asInstanceOf[ChannelBuffer]) match { case Message.RdispatchOk(_, _, rep) => super.writeRequested(ctx, @@ -195,12 +199,12 @@ private[finagle] class PipelineFactory( } } - override def messageReceived(ctx: ChannelHandlerContext, e: MessageEvent) { + override def messageReceived(ctx: ChannelHandlerContext, e: MessageEvent): Unit = { val buf = e.getMessage.asInstanceOf[ChannelBuffer] super.messageReceived(ctx, new UpstreamMessageEvent( e.getChannel, - Message.encode(Message.Tdispatch(Message.MinTag, Seq.empty, Path.empty, Dtab.empty, buf)), + Message.encode(Message.Tdispatch(Message.MinTag, Nil, Path.empty, Dtab.empty, buf)), e.getRemoteAddress)) } } @@ -213,12 +217,12 @@ private[finagle] class PipelineFactory( private[this] val q = new LinkedBlockingDeque[MessageEvent] private[this] val n = new AtomicInteger(pendingReqs) - override def messageReceived(ctx: ChannelHandlerContext, e: MessageEvent) { + override def messageReceived(ctx: ChannelHandlerContext, e: MessageEvent): Unit = { if (n.incrementAndGet() > 1) q.offer(e) else super.messageReceived(ctx, e) } - override def writeRequested(ctx: ChannelHandlerContext, e: MessageEvent) { + override def writeRequested(ctx: ChannelHandlerContext, e: MessageEvent): Unit = { super.writeRequested(ctx, e) if (n.decrementAndGet() > 0) { // Need to call q.take() Since incrementing n and enqueueing the @@ -263,7 +267,7 @@ private[finagle] class PipelineFactory( import Upgrader._ // Queue writes until we know what protocol we are speaking. - private[this] var writeq = new DrainQueue[MessageEvent] + private[this] val writeq = new DrainQueue[MessageEvent] private[this] def isTTwitterUpNegotiation(req: ChannelBuffer): Boolean = { try { @@ -276,12 +280,12 @@ private[finagle] class PipelineFactory( } } - override def writeRequested(ctx: ChannelHandlerContext, e: MessageEvent) { + override def writeRequested(ctx: ChannelHandlerContext, e: MessageEvent): Unit = { if (!writeq.offer(e)) super.writeRequested(ctx, e) } - override def messageReceived(ctx: ChannelHandlerContext, e: MessageEvent) { + override def messageReceived(ctx: ChannelHandlerContext, e: MessageEvent): Unit = { val buf = e.getMessage.asInstanceOf[ChannelBuffer] val pipeline = ctx.getPipeline Try { Message.decode(buf.duplicate()) } match { @@ -333,7 +337,7 @@ private[finagle] class PipelineFactory( new UpstreamMessageEvent( e.getChannel, Message.encode( - Message.Tdispatch(Message.MinTag, Seq.empty, Path.empty, Dtab.empty, buf)), + Message.Tdispatch(Message.MinTag, Nil, Path.empty, Dtab.empty, buf)), e.getRemoteAddress)) } @@ -377,7 +381,7 @@ private[finagle] class PipelineFactory( private[this] val thriftmuxConnectionGauge = statsReceiver.addGauge("connections") { thriftMuxConnectionCount.get() } - def getPipeline() = { + def getPipeline(): ChannelPipeline = { val pipeline = mux.PipelineFactory.getPipeline() pipeline.addLast("upgrader", new Upgrader) pipeline diff --git a/finagle-zipkin/src/main/scala/com/twitter/finagle/zipkin/thrift/Sampler.scala b/finagle-zipkin/src/main/scala/com/twitter/finagle/zipkin/thrift/Sampler.scala index 82da1d5fed..c9567012b5 100644 --- a/finagle-zipkin/src/main/scala/com/twitter/finagle/zipkin/thrift/Sampler.scala +++ b/finagle-zipkin/src/main/scala/com/twitter/finagle/zipkin/thrift/Sampler.scala @@ -12,13 +12,17 @@ object Sampler { * By giving each system a random salt, it is less likely that two * processes will sample the same subset of trace ids. */ - private val salt = (new Random()).nextLong() + private val salt = new Random().nextLong() + + private val SomeTrue = Some(true) + private val SomeFalse = Some(false) } /** * Decide if we should sample a particular trace or not. */ class Sampler { + @volatile private[this] var sr = Sampler.DefaultSampleRate /** @@ -61,7 +65,10 @@ class Sampler { def sampleTrace(traceId: TraceId, sampleRate: Float): Option[Boolean] = { traceId.sampled match { case None => - Some(math.abs(traceId.traceId.toLong^Sampler.salt)%10000 < sampleRate*10000) + if (math.abs(traceId.traceId.toLong^Sampler.salt)%10000 < sampleRate*10000) + Sampler.SomeTrue + else + Sampler.SomeFalse case sample @ Some(_) => sample } diff --git a/finagle-zipkin/src/main/scala/com/twitter/finagle/zipkin/thrift/Span.scala b/finagle-zipkin/src/main/scala/com/twitter/finagle/zipkin/thrift/Span.scala index d798fe871d..467c2d510f 100644 --- a/finagle-zipkin/src/main/scala/com/twitter/finagle/zipkin/thrift/Span.scala +++ b/finagle-zipkin/src/main/scala/com/twitter/finagle/zipkin/thrift/Span.scala @@ -80,5 +80,5 @@ case class Span( } object Span { - def apply(traceId: TraceId): Span = Span(traceId, None, None, Seq(), Seq(), Endpoint.Unknown) + def apply(traceId: TraceId): Span = Span(traceId, None, None, Nil, Nil, Endpoint.Unknown) }