//设置package包名称以及导入依赖的类
package org.argus.jc.incremental.jawa
package remote

import java.net.{ConnectException, InetAddress, UnknownHostException}

import org.argus.jc.incremental.jawa.data.{CompilationData, CompilerData}
import org.jetbrains.jps.incremental.ModuleLevelBuilder.ExitCode


class RemoteServer(val address: InetAddress, val port: Int) extends Server with RemoteResourceOwner {
  def compile(compilerData: CompilerData, compilationData: CompilationData, client: Client): ExitCode = {
    val arguments = Arguments(compilerData, compilationData).asStrings

    try {
      send(serverAlias, arguments, client)
      ExitCode.OK
    } catch {
      case e: ConnectException =>
        val firstLine = s"Cannot connect to compile server at ${address.toString}:$port"
        val secondLine = "Trying to compile without it"
        val message = s"$firstLine\n$secondLine"
        client.warning(message)
        client.debug(s"$firstLine\n${e.toString}\n${e.getStackTrace.mkString("\n")}")
        JawaBuilder.localServer.compile(compilerData, compilationData, client)
      case e: UnknownHostException =>
        val message = "Unknown IP address of compile server host: " + address.toString
        client.error(message)
        client.debug(s"$message\n${e.toString}\n${e.getStackTrace.mkString("\n")}")
        ExitCode.ABORT
    }
  }
} 

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

import java.net.{ UnknownHostException, InetAddress }
import java.util.concurrent.TimeUnit

import akka.actor.Actor
import com.typesafe.config.Config

import scala.collection.immutable

class InetAddressDnsResolver(cache: SimpleDnsCache, config: Config) extends Actor {
  val positiveTtl = config.getDuration("positive-ttl", TimeUnit.MILLISECONDS)
  val negativeTtl = config.getDuration("negative-ttl", TimeUnit.MILLISECONDS)

  override def receive = {
    case Dns.Resolve(name) ?
      val answer = cache.cached(name) match {
        case Some(a) ? a
        case None ?
          try {
            val answer = Dns.Resolved(name, InetAddress.getAllByName(name))
            cache.put(answer, positiveTtl)
            answer
          } catch {
            case e: UnknownHostException ?
              val answer = Dns.Resolved(name, immutable.Seq.empty, immutable.Seq.empty)
              cache.put(answer, negativeTtl)
              answer
          }
      }
      sender() ! answer
  }
} 

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

import java.net.{ UnknownHostException, InetAddress }
import java.util.concurrent.TimeUnit

import akka.actor.Actor
import com.typesafe.config.Config

import scala.collection.immutable

class InetAddressDnsResolver(cache: SimpleDnsCache, config: Config) extends Actor {
  val positiveTtl: Long = config.getDuration("positive-ttl", TimeUnit.MILLISECONDS)
  val negativeTtl: Long = config.getDuration("negative-ttl", TimeUnit.MILLISECONDS)

  override def receive: PartialFunction[Any, Unit] = {
    case Dns.Resolve(name) ?
      val answer = cache.cached(name) match {
        case Some(a) ? a
        case None ?
          try {
            val answer = Dns.Resolved(name, InetAddress.getAllByName(name))
            cache.put(answer, positiveTtl)
            answer
          } catch {
            case e: UnknownHostException ?
              val answer = Dns.Resolved(name, immutable.Seq.empty, immutable.Seq.empty)
              cache.put(answer, negativeTtl)
              answer
          }
      }
      sender() ! answer
  }
} 

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

import java.net.InetAddress
import java.net.UnknownHostException

import se.kth.system.SystemSetup
import se.sics.ktoolbox.util.identifiable.BasicBuilders
import se.sics.ktoolbox.util.identifiable.BasicIdentifiers
import se.sics.ktoolbox.util.identifiable.overlay.OverlayId
import se.sics.ktoolbox.util.network.KAddress
import se.sics.ktoolbox.util.network.basic.BasicAddress
import se.sics.ktoolbox.util.network.nat.NatAwareAddressImpl


object ScenarioSetup {

  val scenarioSeed: Long = 1234
  val appPort: Int = 12345
  var bootstrapServer: KAddress = null
  var croupierOId: OverlayId = null

  {
    croupierOId = SystemSetup.setup()
    val bootstrapId = BasicIdentifiers.nodeId(new BasicBuilders.IntBuilder(0))
    try {
      bootstrapServer = NatAwareAddressImpl.open(new BasicAddress(InetAddress.getByName("193.0.0.1"), appPort, bootstrapId));
    }
    catch {
      case ex: UnknownHostException => throw new RuntimeException(ex)
    }
  }

  def getNodeAdr(nodeIp: String, baseNodeId: Int): KAddress = {
    try {
      val nodeId = BasicIdentifiers.nodeId(new BasicBuilders.IntBuilder(baseNodeId))
      NatAwareAddressImpl.open(new BasicAddress(InetAddress.getByName(nodeIp), appPort, nodeId))
    } catch {
      case ex: UnknownHostException => {
        throw new RuntimeException(ex)
      }
    }
  }

  def getNodeSeed(nodeId: Int): Long = scenarioSeed + nodeId
} 

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

import java.net.{InetSocketAddress, UnknownHostException}

import io.netty.bootstrap.Bootstrap
import io.netty.channel._
import io.netty.channel.socket.SocketChannel
import io.netty.channel.socket.nio.NioSocketChannel
import tk.dasb.codec.{ReplyEncoder, ReqDecoder}
import tk.dasb.protocol.{Reply, Req}
import tk.dasb.util.{FutureConv, Log}


class ConnectHandler(val req: Req) extends ChannelInboundHandlerAdapter with Log  with FutureConv{

  var  closeAll: ()=>Any = ()=>{}

  override def exceptionCaught(ctx: ChannelHandlerContext, cause: Throwable): Unit = closeAll()

  override def channelInactive(ctx: ChannelHandlerContext): Unit = closeAll()

  override def channelActive(ctx: ChannelHandlerContext): Unit = {

    val b = new Bootstrap
    b.group(ctx.channel.eventLoop).channel(classOf[NioSocketChannel])
      .option[java.lang.Boolean](ChannelOption.SO_KEEPALIVE, true).option[java.lang.Boolean](ChannelOption.TCP_NODELAY, true)
      .handler(new ChannelInitializer[SocketChannel] {
        override def initChannel(ch: SocketChannel): Unit = {}
      })


    log.debug("connecting:{}", req.dstAddress)
    b.connect(req.dstAddress).success{
      connFuture =>
        log.debug("connect success")
        ctx.writeAndFlush(Reply.connSuccess(ctx.channel.localAddress.asInstanceOf[InetSocketAddress])).success{
          writeFuture =>
            closeAll = ()=> {
              ctx.close()
              connFuture.channel().close()
            }
            ctx.pipeline.remove(classOf[ReqDecoder])
            ctx.pipeline.remove(classOf[ReqHandler])
            ctx.pipeline.remove(classOf[ReplyEncoder])
            ctx.pipeline.remove(ConnectHandler.this)
            ctx.pipeline.addLast(new PipHandler(connFuture.channel)) // client -> proxy
            connFuture.channel.pipeline.addFirst(new PipHandler(writeFuture.channel)) // remote -> proxy
        }
    }.failed{
      connFuture=>
        connFuture.cause match {
          case _: UnknownHostException =>
            ctx.writeAndFlush(Reply.failed(req.dstAddress, Reply.FAILURE_HOST_UNREACH)).Close
          case _ =>
            ctx.writeAndFlush(Reply.failed(req.dstAddress, Reply.FAILURE_SERVER)).Close
        }
    }
  }

} 

//设置package包名称以及导入依赖的类
package com.avsystem.scex.util

import java.net.{InetAddress, UnknownHostException}

import com.avsystem.scex.util.function.NetFunctions

final class StringNetworkOps(private val wrapped: String) extends AnyVal {
  def isIpInSubnet(subnetWithMask: String): Boolean =
    NetFunctions.isIpInSubnet(wrapped, subnetWithMask)

  def isIpInSubnetWithMask(subnet: String, mask: String): Boolean =
    NetFunctions.isIpInSubnetWithMask(wrapped, subnet, mask)

  def stripMac: String = NetFunctions.stripMac(wrapped)
  def isIp: Boolean = NetFunctions.isIp(wrapped)
  def isIps: Boolean = NetFunctions.isIps(wrapped)
  def isMac: Boolean = NetFunctions.isMac(wrapped)

  def compareAsIpTo(ip: String): Integer = try {
    val adr1 = InetAddress.getByName(wrapped)
    val adr2 = InetAddress.getByName(ip)
    val inetAddressComparator = new NetFunctions.InetAddressComparator
    inetAddressComparator.compare(adr1, adr2)
  } catch {
    case _: UnknownHostException => null
  }
}