//设置package包名称以及导入依赖的类
package tech.artemisia.core

import java.nio.file.Paths
import ch.qos.logback.classic.LoggerContext
import ch.qos.logback.classic.joran.JoranConfigurator
import com.typesafe.config.Config
import org.slf4j.LoggerFactory
import tech.artemisia.config.{AppContext, AppSetting}
import tech.artemisia.core.dag.{ActorSysManager, Dag}
import tech.artemisia.task.TaskContext
import tech.artemisia.util.HoconConfigUtil.Handler



object Command {

  private def prepareAppContext(cmd_line_params: AppSetting) = {
    val appContext = new AppContext(cmd_line_params)
    configureLogging(appContext)
    AppLogger debug s"workflow_id: ${appContext.runId}"
    AppLogger debug s"working directory: ${appContext.workingDir}"
    if (appContext.globalConfigFile.nonEmpty) {
      AppLogger debug s"global config file: ${appContext.globalConfigFile.get}"
    }
    TaskContext.setWorkingDir(Paths.get(appContext.workingDir))
    TaskContext.predefinedConnectionProfiles = TaskContext.parseConnections(
      appContext.payload.as[Config](Keywords.Config.CONNECTION_SECTION))
    appContext
  }


  private def configureLogging(app_context: AppContext) = {
      val context = LoggerFactory.getILoggerFactory.asInstanceOf[LoggerContext]
      val jc = new JoranConfigurator
      jc.setContext(context)
      context.reset()
      context.putProperty("log.console.level", app_context.logging.console_trace_level)
      context.putProperty("log.file.level", app_context.logging.file_trace_level)
      context.putProperty("env.working_dir", app_context.coreSetting.working_dir)
      context.putProperty("workflow_id", app_context.runId)
      jc.doConfigure(this.getClass.getResourceAsStream("/logback_config.xml"))
  }


  def run(cmd_line_params: AppSetting) = {
    AppLogger info "request for run command acknowledged"
    val app_context = prepareAppContext(cmd_line_params)
    AppLogger debug "context object created"
    TaskContext.setWorkingDir(Paths.get(app_context.workingDir))
    val dag = Dag(app_context)
    AppLogger debug "starting Actor System"
    val actor_sys_manager =  new ActorSysManager(app_context)
    val workers = actor_sys_manager.createWorker(Keywords.ActorSys.CUSTOM_DISPATCHER)
    val dag_player = actor_sys_manager.createPlayer(dag,workers)
    dag_player ! 'Play
  }

  def doc(cmd_line_params: AppSetting) = {
  }

} 

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

import java.net.URL

import ch.qos.logback.classic.LoggerContext
import ch.qos.logback.classic.joran.JoranConfigurator
import com.typesafe.scalalogging.LazyLogging
import org.slf4j.LoggerFactory

trait Logger extends LazyLogging
object Logger {
  def setLogConfFile(path: Either[URL, String]) = {
    val ctx = LoggerFactory.getILoggerFactory.asInstanceOf[LoggerContext]
    val conf = new JoranConfigurator
    conf.setContext(ctx)
    ctx.reset()
    path match {
      case Left(url) => conf.doConfigure(url)
      case Right(fileName) => conf.doConfigure(fileName)
    }
  }
} 

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

import javax.inject.{Inject, Singleton}

import ch.qos.logback.classic.LoggerContext
import com.codahale.metrics.MetricRegistry
import com.codahale.metrics.logback.InstrumentedAppender
import org.slf4j.{Logger, LoggerFactory}

@Singleton
class InstrumentLogging @Inject()(metricRegistry: MetricRegistry) {
  InstrumentLogging.instrument(metricRegistry)
}

object InstrumentLogging {
  def instrument(metricRegistry: MetricRegistry): Unit = {
    val factory = LoggerFactory.getILoggerFactory.asInstanceOf[LoggerContext]
    val root    = factory.getLogger(Logger.ROOT_LOGGER_NAME)

    val instrumentedAppended = new InstrumentedAppender(metricRegistry)
    instrumentedAppended.setContext(root.getLoggerContext)
    instrumentedAppended.start()
    root.addAppender(instrumentedAppended)
  }
} 

//设置package包名称以及导入依赖的类
import ch.qos.logback.classic.LoggerContext
import ch.qos.logback.classic.joran.JoranConfigurator
import command._
import org.slf4j.{Logger, LoggerFactory}

object Cmd extends CommandUtils {
  def commands: Map[String, () => Command] = Map(
    "archive" -> ArchiveCommand,
    "convert-month" -> ConvertMonthCommand,
    "convert-year" -> ConvertYearCommand,
    "get" -> GetCommand.apply,
    "info" -> InfoCommand,
    "update" -> UpdateCommand
  )

  def run(args: Array[String], isDev: Boolean): Unit = {
    if (args.length < 1) {
      println("Usage: <command> [parameters...]")
      println("Available commands: " + commands.keys.toVector.sorted.mkString(", "))
      sys.exit(-1)
    }

    val cmdName = args(0)
    val cmd: Command = commands.getOrElse(cmdName, exitError("Unknown command: " + cmdName))()

    configureLogback(
      if (isDev) "logback-dev.xml"
      else if (cmd.isVerbose) "logback-prod-verbose.xml" else "logback-prod.xml")

    val params: Array[String] = args.drop(1)
    val log: Logger = LoggerFactory.getLogger("main")
    log.info("Run: " + args.mkString(" "))
    cmd.run(log, params)
  }

  private def configureLogback(configFilename: String): Unit = {
    val configurator: JoranConfigurator = new JoranConfigurator
    val ctx: LoggerContext = LoggerFactory.getILoggerFactory.asInstanceOf[LoggerContext]
    configurator.setContext(ctx)
    ctx.reset()
    configurator.doConfigure(getClass.getClassLoader.getResource(configFilename))
  }

  def main(args: Array[String]) {
    run(args, isDev = false)
  }
} 

//设置package包名称以及导入依赖的类
package uk.ac.wellcome.test.utils

import ch.qos.logback.classic.LoggerContext
import ch.qos.logback.classic.joran.JoranConfigurator
import org.slf4j.LoggerFactory

trait StartupLogbackOverride {
  val loggerContext =
    LoggerFactory.getILoggerFactory.asInstanceOf[LoggerContext]
  loggerContext.reset
  val configurator = new JoranConfigurator
  configurator.setContext(loggerContext)
  configurator.doConfigure(
    getClass
      .getResourceAsStream("/logback-startup-test.xml"))
} 

//设置package包名称以及导入依赖的类
package faunadb.importer.report

import ch.qos.logback.classic.LoggerContext
import org.slf4j._

object Log {
  private val info = LoggerFactory.getLogger("info")
  private val error = LoggerFactory.getLogger("error")
  private val fatal = LoggerFactory.getLogger("fatal")

  @volatile private var statusLine: String = ""
  @volatile private var lastSize: Int = 0

  def info(msg: String): Unit = syncInfo(_.info(msg))
  def warn(msg: String): Unit = syncInfo(_.warn(s"[WARN] $msg"))

  private def syncInfo(f: Logger => Unit): Unit = {
    if (lastSize > 0) {
      synchronized {
        print(fillLine())
        f(info)
        print(statusLine)
      }
    } else {
      f(info)
    }
  }

  def status(line: String) {
    if (info.isInfoEnabled()) {
      synchronized {
        print(fillLine(line))
        lastSize = line.length
        statusLine = line
      }
    }
  }

  def clearStatus(): Unit = status("")

  private def fillLine(line: String = ""): String =
    s"\r\r$line${" " * Math.max(0, lastSize - line.length)}\r"

  def error(msg: String): Unit = error.error(msg)
  def fatal(err: Throwable): Unit = fatal.error(err.getMessage, err)

  def stop() {
    LoggerFactory.getILoggerFactory match {
      case c: LoggerContext => c.stop()
      case _                =>
    }
  }
} 

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

import java.io.File

import ch.qos.logback.classic.LoggerContext
import io.iohk.iodb.{ByteArrayWrapper, LSMStore, Store, TestUtils}
import org.slf4j.LoggerFactory


object InitialProcessing extends Benchmark {
  val Milestones = Seq(1000, 5000, 10000, 50000, 100000, 250000, 500000, 750000, 1000000)

  val Inputs = 5500
  //average number of inputs per block
  val Outputs = 6000 //average number of outputs per block

  def bench(store: Store, dir: File): Unit = {
    println(s"Store: $store")

    Milestones.foldLeft((0, 0L, Seq[ByteArrayWrapper]())) {
      case ((prevMilestone, prevTime, prevCache), milestone) =>
        val (time, newCache) = TestUtils.runningTime {
          (prevMilestone + 1 to milestone).foldLeft(prevCache) { case (cache, version) =>
            processBlock(version, store, Inputs, Outputs, cache).get.take(Inputs * 100)
          }
        }
        val newTime = prevTime + time
        println(s"Time  to get to $milestone: $time")
        (milestone, newTime, newCache)
    }

    store.close()
    TestUtils.deleteRecur(dir)
  }

  def main(args: Array[String]): Unit = {
    //switching off logging
    val context = LoggerFactory.getILoggerFactory.asInstanceOf[LoggerContext]
    context.stop()

    var dir = TestUtils.tempDir()
    bench(new LSMStore(dir, keySize = KeySize), dir)

    System.gc()
    Thread.sleep(15000)
    println("======================================")

    dir = TestUtils.tempDir()
    bench(new RocksStore(dir), dir)
  }
} 

//设置package包名称以及导入依赖的类
import turksem.qamr._
import turksem.util._
import turkey._
import turkey.tasks._
import akka.pattern.ask
import scala.concurrent.duration._
val annotationPath = java.nio.file.Paths.get("annotations")
implicit val timeout = akka.util.Timeout(5.seconds)
implicit val config: TaskConfig = {
  val isProduction = false // sandbox. change to true for production
  if(isProduction) {
    val hitDataService = new FileSystemHITDataService(annotationPath.resolve("production"))
    ProductionTaskConfig("qamr-emnlp2017", "localhost", hitDataService)
  } else {
    val hitDataService = new FileSystemHITDataService(annotationPath.resolve("sandbox"))
    SandboxTaskConfig("qamr-emnlp2017", "localhost", hitDataService)
  }
}
def exit = {
  // actor system has to be terminated for JVM to be able to terminate properly upon :q
  config.actorSystem.terminate
  // flush & release logging resources
  import org.slf4j.LoggerFactory
  import ch.qos.logback.classic.LoggerContext
  LoggerFactory.getILoggerFactory.asInstanceOf[LoggerContext].stop
  System.out.println("Terminated actor system and logging. Type :q to end.")
}

val setup = new emnlp2017.AnnotationSetup
val exp = setup.experiment
exp.server 

//设置package包名称以及导入依赖的类
import turksem.qamr._
import turksem.util._
import turkey._
import turkey.tasks._
import akka.pattern.ask
import scala.concurrent.duration._

val isProduction = false // sandbox. change to true for production
val domain = "nlp.cs.washington.edu" // change to your comain, or keep localhost for testing
val projectName = "qamr-ai2" // make sure it matches the SBT project;
// this is how the .js file is found to send to the server

val annotationPath = java.nio.file.Paths.get("annotations")
implicit val timeout = akka.util.Timeout(5.seconds)
implicit val config: TaskConfig = {
  if(isProduction) {
    val hitDataService = new FileSystemHITDataService(annotationPath.resolve("production"))
    ProductionTaskConfig(projectName, domain, hitDataService)
  } else {
    val hitDataService = new FileSystemHITDataService(annotationPath.resolve("sandbox"))
    SandboxTaskConfig(projectName, domain, hitDataService)
  }
}
def exit = {
  // actor system has to be terminated for JVM to be able to terminate properly upon :q
  config.actorSystem.terminate
  // flush & release logging resources
  import org.slf4j.LoggerFactory
  import ch.qos.logback.classic.LoggerContext
  LoggerFactory.getILoggerFactory.asInstanceOf[LoggerContext].stop
  System.out.println("Terminated actor system and logging. Type :q to end.")
}

val setup = new ai2.Ai2AnnotationSetup
val exp = setup.experiment
exp.server 

//设置package包名称以及导入依赖的类
package x7c1.wheat.splicer.core.logger

import ch.qos.logback.classic.spi.ILoggingEvent
import ch.qos.logback.classic.{Level, LoggerContext}
import ch.qos.logback.core.util.ContextUtil
import ch.qos.logback.{classic, core}
import org.slf4j
import x7c1.wheat.splicer.core.logger.Tap.implicits.Provider


trait LoggerFactory {

  val context: LoggerContext =
    slf4j.LoggerFactory.getILoggerFactory.asInstanceOf[LoggerContext] tap { x =>
      val util = new ContextUtil(x)
      val add = util.addFrameworkPackage(x.getFrameworkPackages, _: String)
      (frameworkPackages :+ getClass.getPackage.getName) foreach add
    }

  val appenderFactories: Seq[Appender.Factory]

  lazy val appenders: Seq[core.Appender[ILoggingEvent]] = {
    appenderFactories.map(_ (context))
  }

  def level: Level

  def frameworkPackages: Seq[String] = Seq()

  def apply[X](klass: Class[X]): slf4j.Logger = {
    slf4j.LoggerFactory.getLogger(klass).asInstanceOf[classic.Logger].tap(
      appenders foreach _.addAppender,
      _ setLevel level,
      _ setAdditive false
    )
  }

}

object Appender {

  type Factory = LoggerContext => core.Appender[ILoggingEvent]

  type From[X] = X => Factory

  def from[X: From](x: X): Factory = {
    implicitly[From[X]] apply x
  }
}