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

import java.nio.file.{Files, Paths, StandardOpenOption}
import com.twitter.finagle.util.DefaultTimer
import com.twitter.io.Charsets
import com.twitter.util.Duration

case class SnapshotLogger(outputFilePath: String,
                          dtFlush: Duration,
                          enabled: Boolean,
                          fGetSnapshot: () => String) {

  private val path = Paths.get(outputFilePath)

  if (enabled) {
    DefaultTimer.twitter.schedule(dtFlush) {
      Files.write(path, fGetSnapshot().getBytes(Charsets.Utf8), StandardOpenOption.WRITE, StandardOpenOption.CREATE)
    }
  }

} 

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

import java.nio.file.{Files, Paths, StandardOpenOption}
import java.util.concurrent.atomic.AtomicLong
import com.twitter.finagle.util.DefaultTimer
import com.twitter.io.Charsets
import com.twitter.util.Duration
import scala.util.Try
import scala.collection.JavaConversions._

case class DataUseLogger(outputFilePath: String, dtFlush: Duration, enabled: Boolean) {

  private val atomicDelta = new AtomicLong(0L)
  private val path = Paths.get(outputFilePath)

  if (enabled) {
    DefaultTimer.twitter.schedule(dtFlush) {
      val delta = atomicDelta.getAndSet(0)
      val prevBytes = Try(Files.readAllLines(path, Charsets.Utf8).head.toLong).getOrElse(0L)
      val newVal = ((prevBytes + delta).toString + "\n").getBytes(Charsets.Utf8)
      Files.write(path, newVal, StandardOpenOption.WRITE, StandardOpenOption.CREATE)
    }
  }

  def log(nBytes: Long): Unit = {
    atomicDelta.addAndGet(nBytes)
  }

} 

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

import scala.collection.JavaConversions._
import java.io.File
import java.nio.channels.FileChannel
import java.nio.file.StandardOpenOption
import java.nio.channels.FileChannel.MapMode
import java.nio.ByteBuffer
import scala.Range

class TorrentFileStream(channel: FileChannel, buffer: ByteBuffer) extends BStream {
  def headChar: Char = buffer.duplicate.get.asInstanceOf[Char]
  def headByte: Byte = buffer.duplicate.get
  def tail = {
    val tail = buffer.duplicate
    tail.get
    new TorrentFileStream(channel, tail)
  }
  def isEmpty = !buffer.hasRemaining
  def close: Unit = channel.close
  override def toString: String = {
    val buff = buffer.duplicate
    val builder = StringBuilder.newBuilder
    while (buff.hasRemaining) {
      if (builder.endsWith("6:pieces")) {
        val bah = StringBuilder.newBuilder
        var chaaa = buff.get.asInstanceOf[Char]
        while ("0123456789".contains(chaaa)) {
          bah.append(chaaa)
          chaaa = buff.get.asInstanceOf[Char]
        }
        var i = bah.toString.toInt
        while(i >= 0){
          buff.get
          i = i-1
        }
      }
      builder += buff.get.asInstanceOf[Char]
    }
    builder.toString
  }
}
object TorrentFileStream {
  def apply(torrent: File) = {
    val channel = FileChannel.open(torrent.toPath, StandardOpenOption.READ)
    new TorrentFileStream(channel, channel.map(MapMode.READ_ONLY, 0, channel.size).load)
  }
} 

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

import java.nio.channels.FileChannel
import java.io.File
import java.nio.file.StandardOpenOption
import scala.util.Random
import java.nio.ByteBuffer
import com.spooky.bittorrent.u.GigaByte

object RandomFile {
  def main(args: Array[String]): Unit = {
    val channel = FileChannel.open(new File("O:\\tmp\\file.dump").toPath, StandardOpenOption.WRITE, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING);
    val r = new Random(0)
    val buffer = ByteBuffer.allocate(1024 * 4)
    val bytes = GigaByte(50).toBytes
    println(bytes.capacity.toLong)
    for (_ <- 0l to(bytes.capacity.toLong, buffer.capacity.toLong)) {
      r.nextBytes(buffer.array())
      buffer.limit(buffer.capacity)
      buffer.position(0)
      channel.write(buffer)
    }
    channel.close()
  }
} 

//设置package包名称以及导入依赖的类
import java.nio.channels.FileChannel
import java.nio.charset.StandardCharsets
import java.nio.file.{Paths, StandardOpenOption}
import java.nio.{ByteBuffer, ByteOrder}
import sys.process._
import scala.collection.immutable.Range.Inclusive
import scala.collection.mutable
import scala.collection.mutable.ArrayBuffer

import org.scalatest.FlatSpec
import com.indix.ml2npy.NpyFile


class NpyFileSpec extends FlatSpec{
  val nosetestspath="nosetests "
  val pathToTest = getClass.getResource("/python/Npytest.py").getPath+":"
  "NpyFile" should "Convert a float array correctly" in {
    val content = NpyFile[Float].addElements(Seq(0.3f, 0.5f))
    val channel = FileChannel.open(Paths.get("/tmp/test.npy"), StandardOpenOption.WRITE, StandardOpenOption.TRUNCATE_EXISTING, StandardOpenOption.CREATE)
    channel.write(content)
    channel.close()
    val command=nosetestspath + pathToTest+"test_0"
    val response=command.!
    assert(response==0)
  }

  "NpyFile" should "Convert a sequence of integers correctly" in {
    val intContent = NpyFile[Int].addElements(1 to 10)
    val intChannel = FileChannel.open(Paths.get("/tmp/inttest.npy"), StandardOpenOption.WRITE, StandardOpenOption.TRUNCATE_EXISTING, StandardOpenOption.CREATE)
    intChannel.write(intContent)
    intChannel.close()
    val command=nosetestspath + pathToTest+"test_1"
    val response=command.!
    assert(response==0)
  }

  "NpyFile" should "write bytes directly" in {
    val data: Inclusive = 1 to 10
    val intContent3 = NpyFile[Int]
    data.foreach(intContent3.addToBuffer)
    val bytes = intContent3.getBytes
    val intChannel3 = FileChannel.open(Paths.get("/tmp/inttest3.npy"), StandardOpenOption.WRITE, StandardOpenOption.TRUNCATE_EXISTING, StandardOpenOption.CREATE)
    intChannel3.write(ByteBuffer.wrap(bytes))
    intChannel3.close()
    val command=nosetestspath + pathToTest+"test_3"
    val response=command.!
    assert(response==0)
  }
} 

//设置package包名称以及导入依赖的类
package codacy.dockerApi.utils

import java.io.File
import java.nio.charset.StandardCharsets
import java.nio.file.{Files, Path, Paths, StandardOpenOption}

object FileHelper {

  def createTmpFile(content: String, prefix: String = "config", suffix: String = ".conf"): Path = {
    Files.write(
      Files.createTempFile(prefix, suffix),
      content.getBytes(StandardCharsets.UTF_8),
      StandardOpenOption.CREATE
    )
  }

  def stripPath(filename: Path, prefix: Path): String = {
    stripPath(filename.toString, prefix.toString)
  }

  def stripPath(filename: String, prefix: String): String = {
    filename.stripPrefix(prefix)
      .stripPrefix("/")
  }

  def listAllFiles(path: String): List[File] = {
    listAllFiles(Paths.get(path))
  }

  def listAllFiles(path: Path): List[File] = {
    recursiveListFiles(path.toFile)
  }

  private def recursiveListFiles(file: File): List[File] = {
    val these = file.listFiles
    (these ++ these.filter(_.isDirectory).flatMap(recursiveListFiles)).toList
  }

} 

//设置package包名称以及导入依赖的类
package com.harry0000.kancolle.ac

import java.io.File
import java.nio.charset.StandardCharsets.UTF_8
import java.nio.file.{Files, StandardOpenOption}

object Main {

  def main(args: Array[String]): Unit = {
    val path = Config.distPath
    val areas = PlaceCrawler.crawl()

    writeCSV(path, "place.csv", areas)
    writeJSON(path, "place.json", areas)
  }

  val headers = Seq("area", "prefecture_code", "prefecture_name", "place_name", "place_address")

  def writeCSV(path: String, name: String, areas: Seq[Area]): Unit = {
    import com.github.tototoshi.csv.CSVWriter

    val writer = CSVWriter.open(new File(path, name))
    try {
      writer.writeRow(headers)

      for {
        area  <- areas
        pref  <- area.prefectures
        place <- pref.places
      } {
        writer.writeRow(Seq(area.name, pref.code, pref.name, place.name, place.address))
      }
    } finally {
      writer.close()
    }
  }

  def writeJSON(path: String, name: String, areas: Seq[Area]): Unit = {
    import spray.json._
    import PlaceCrawler._

    val writer = Files.newBufferedWriter(new File(path, name).toPath, UTF_8, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING)
    try {
      writer.write(areas.toJson.prettyPrint)
    } finally {
      writer.close()
    }
  }
} 

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

import java.io.File
import java.nio.channels.FileChannel
import java.nio.file.{FileSystems, Files, Path, StandardOpenOption}

import scala.util.control.NonFatal
import com.typesafe.config.Config
import swave.core.impl.util.SettingsCompanion
import swave.core.io.Bytes
import swave.core.macros._

object FileIO extends SpoutFromFiles with DrainToFiles {

  lazy val userHomePath: Path = FileSystems.getDefault.getPath(System getProperty "user.home")

  def resolveFileSystemPath(pathName: String): Path =
    if (pathName.length >= 2 && pathName.charAt(0) == '~' && pathName.charAt(1) == File.separatorChar) {
      userHomePath.resolve(pathName substring 2)
    } else FileSystems.getDefault.getPath(pathName)

  val WriteCreateOptions: Set[StandardOpenOption] = {
    import StandardOpenOption._
    Set(CREATE, TRUNCATE_EXISTING, WRITE)
  }

  final case class Settings(defaultFileReadingChunkSize: Int, defaultFileWritingChunkSize: Int) {
    requireArg(defaultFileReadingChunkSize > 0, "`defaultFileChunkSize` must be > 0")
    requireArg(defaultFileWritingChunkSize >= 0, "`defaultFileWritingChunkSize` must be >= 0")

    def withDefaultFileReadingChunkSize(defaultFileReadingChunkSize: Int) =
      copy(defaultFileReadingChunkSize = defaultFileReadingChunkSize)
    def withDefaultFileWritingChunkSize(defaultFileWritingChunkSize: Int) =
      copy(defaultFileWritingChunkSize = defaultFileWritingChunkSize)
  }

  object Settings extends SettingsCompanion[Settings]("swave.core.file-io") {
    def fromSubConfig(c: Config): Settings =
      Settings(
        defaultFileReadingChunkSize = c getInt "default-file-reading-chunk-size",
        defaultFileWritingChunkSize = c getInt "default-file-writing-chunk-size")
  }

  def writeFile[T: Bytes](fileName: String, data: T): Unit = writeFile(resolveFileSystemPath(fileName), data)
  def writeFile[T: Bytes](file: File, data: T): Unit       = writeFile(file.toPath, data)
  def writeFile[T: Bytes](path: Path, data: T, options: StandardOpenOption*): Unit = {
    implicit def decorator(value: T): Bytes.Decorator[T] = Bytes.decorator(value)
    Files.write(path, data.toArray, options: _*)
    ()
  }

  def readFile[T: Bytes](fileName: String): T = readFile(resolveFileSystemPath(fileName))
  def readFile[T: Bytes](file: File): T       = readFile(file.toPath)
  def readFile[T: Bytes](path: Path): T       = implicitly[Bytes[T]].apply(Files.readAllBytes(path))

  private[io] def quietClose(channel: FileChannel): Unit =
    try channel.close()
    catch { case NonFatal(_) ? }
} 

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

import java.nio.charset.StandardCharsets
import java.nio.file.{Files, Paths, StandardOpenOption}

import definiti.core._

import scala.collection.JavaConverters._

object Boot extends App {
  try {
    val configuration = Configuration(
      source = Paths.get("src", "main", "resources", "samples", "first.def"),
      core = CoreConfiguration(
        source = Paths.get("src", "main", "resources", "api")
      )
    )
    val destination = Paths.get("target", "samples", "result.scala")

    val project = new Project(configuration)
    project.load() match {
      case Left(errors) =>
        errors.foreach(System.err.println)
      case Right(projectResult) =>
        val root = projectResult.root
        implicit val contexte = projectResult.context
        val result = ScalaASTBuilder.build(root)
        Files.createDirectories(destination.getParent)
        Files.write(destination, Seq(result).asJava, StandardCharsets.UTF_8, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING)
    }
  } catch {
    // In some cases, an Exception is thrown because the parser do not recognize an expression and crash its tree.
    // Did not happened with a successful syntax yet.
    case e: Exception =>
      e.printStackTrace()
  }
} 

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

import java.nio.channels.{FileChannel, FileLock}
import java.nio.file.{Files, OpenOption, Paths, StandardOpenOption}


class FolderLock  (folder: => String) extends Lock {
  var isLocked = false
  lazy val lockFolder = Paths.get(folder)
  lazy val lockFilePath = Paths.get(folder, ".lock")
  var channel: FileChannel = null
  var flock: FileLock = null
  override def lock(): Lock = {
    try {
      this synchronized {
        if(isLocked) return this
        if(Files.notExists(lockFolder)) Files.createDirectories(lockFolder)
        if(Files.notExists(lockFilePath)) Files.createFile(lockFilePath)
        logger.debug(s"created file $lockFilePath")
        channel = FileChannel.open(lockFilePath, StandardOpenOption.CREATE, StandardOpenOption.WRITE)
        flock = channel.lock()
        logger.debug(s"acquired lock")
        isLocked = true
        this
      }
    } catch {
      case ex: Exception => {
        logger.error(s"exception while locking: $ex")
        if(isLocked) release()
        throw ex
      }
    }
  }

  override def tryLock(): Boolean =  {
    try {
      lock()
      true
    } catch {
      case ex: Exception => false
    }
  }

  override def release(): Unit = {
    try {
      this synchronized {
        if(!isLocked) return
        if (flock != null) flock.release()
        if (channel != null && channel.isOpen) channel.close()
        if (Files.exists(lockFilePath)) Files.delete(lockFilePath)
        logger.debug(s"lock released $lockFilePath")
        isLocked = false
      }
    } catch {
      case ex: Exception => {
        logger.error(s"exception while releasing lock: $ex")
      } //TODO: handle exception
    }
  }
} 

//设置package包名称以及导入依赖的类
package it.milczarek.gpwquoter.file

import java.io.File
import java.net.URL
import java.nio.file.{Files, Path, Paths, StandardOpenOption}

import it.milczarek.gpwquoter.AppConfig
import org.apache.http.client.fluent.Request
import org.slf4j.LoggerFactory

import scala.util.{Failure, Success, Try}


class FileDownloader(appConfig: AppConfig) {

  private val logger = LoggerFactory.getLogger(classOf[FileDownloader])

  def download(url: URL): Try[File] = {
    try {
      logger.info(s"Download file: $url")
      val response = Request.Get(url.toString).execute().returnContent().asBytes()
      val file = Files.write(outputFile(url), response, StandardOpenOption.CREATE).toFile
      Success(file)
    } catch {
      case e: Throwable => Failure(e)
    }
  }

  def outputFile(url: URL): Path = {
    val dir = new File(appConfig.dataFilesLocation)
    if (!dir.exists) dir.mkdirs()
    val uri = url.getFile
    val startFileName = uri.lastIndexOf("/") + 1
    Paths.get(appConfig.dataFilesLocation, uri.substring(startFileName))
  }

} 

//设置package包名称以及导入依赖的类
package me.snov.sns.service

import java.nio.charset.StandardCharsets
import java.nio.file.{Files, Paths, StandardOpenOption}

import akka.event.LoggingAdapter
import me.snov.sns.model.Configuration
import spray.json._

class DbService(dbFilePath: String)(implicit log: LoggingAdapter) {

  val subscriptionsName = "subscriptions"
  val topicsName = "topics"
  
  val path = Paths.get(dbFilePath)
  
  def load(): Option[Configuration] = {
    if (Files.exists(path)) {
      log.debug("Loading DB")
      try {
        val configuration = read().parseJson.convertTo[Configuration]
        log.info("Loaded DB")
        return Some(configuration)
      } catch {
        case e: DeserializationException => log.warning("Unable to parse configuration")
        case e: RuntimeException => log.warning("Unable to load configuration")
      }
    }
    None
  }
  
  def save(configuration: Configuration) = {
    log.debug("Saving DB")
    write(configuration.toJson.prettyPrint)
  }

  private def write(contents: String) = {
    Files.write(path, contents.getBytes(StandardCharsets.UTF_8), StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING)
  }

  private def read(): String = {
    new String(Files.readAllBytes(path))
  }
} 

//设置package包名称以及导入依赖的类
package com.codacy.dotnet.helpers

import java.io.InputStream
import java.nio.charset.{CodingErrorAction, StandardCharsets}
import java.nio.file.{Files, Path, StandardOpenOption}

import scala.io.Codec
import scala.util.{Failure, Try}

object ResourceHelper {

  implicit val codec = Codec("UTF-8")
  codec.onMalformedInput(CodingErrorAction.REPLACE)
  codec.onUnmappableCharacter(CodingErrorAction.REPLACE)

  def getResourceStream(path: String): Try[InputStream] = {
    Option(getClass.getClassLoader.getResource(path)).map { url =>
      Try(url.openStream())
    }.getOrElse {
      Failure(new Exception("The path provided was not found"))
    }
  }

  def writeFile(path: Path, content: String): Try[Path] = {
    Try(Files.write(
      path,
      content.getBytes(StandardCharsets.UTF_8),
      StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING, StandardOpenOption.WRITE
    ))
  }

} 

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

import java.nio.file.{Files, StandardOpenOption}
import java.util.Date

import com.lightbend.lagom.scaladsl.api.ServiceLocator.NoServiceLocator
import com.lightbend.lagom.scaladsl.server._
import com.lightbend.lagom.scaladsl.devmode.LagomDevModeComponents
import play.api.libs.ws.ahc.AhcWSComponents
import api.BazService
import com.softwaremill.macwire._

class BazLoader extends LagomApplicationLoader {

  override def load(context: LagomApplicationContext): LagomApplication =
    new BazApplication(context) {
      override def serviceLocator = NoServiceLocator
    }

  override def loadDevMode(context: LagomApplicationContext): LagomApplication =
    new BazApplication(context) with LagomDevModeComponents
}

abstract class BazApplication(context: LagomApplicationContext)
  extends LagomApplication(context)
    with AhcWSComponents {

  override lazy val lagomServer =serverFor[BazService](wire[BazServiceImpl])


  Files.write(environment.getFile("target/reload.log").toPath, s"${new Date()} - reloaded\n".getBytes("utf-8"),
    StandardOpenOption.CREATE, StandardOpenOption.APPEND)
} 

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

import java.nio.file.{Files, StandardOpenOption}
import java.util.Date

import com.lightbend.lagom.scaladsl.api.ServiceLocator.NoServiceLocator
import com.lightbend.lagom.scaladsl.server._
import com.lightbend.lagom.scaladsl.devmode.LagomDevModeComponents
import play.api.libs.ws.ahc.AhcWSComponents
import api.{BarService, FooService}
import com.softwaremill.macwire._

class BarLoader extends LagomApplicationLoader {

  override def load(context: LagomApplicationContext): LagomApplication =
    new BarApplication(context) {
      override def serviceLocator = NoServiceLocator
    }

  override def loadDevMode(context: LagomApplicationContext): LagomApplication =
    new BarApplication(context) with LagomDevModeComponents
}

abstract class BarApplication(context: LagomApplicationContext)
  extends LagomApplication(context)
    with AhcWSComponents {

  override lazy val lagomServer = serverFor[BarService](wire[BarServiceImpl])


  lazy val fooService = serviceClient.implement[FooService]

  Files.write(environment.getFile("target/reload.log").toPath, s"${new Date()} - reloaded\n".getBytes("utf-8"),
    StandardOpenOption.CREATE, StandardOpenOption.APPEND)
} 

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

import java.nio.file.{Files, StandardOpenOption}
import java.util.Date

import com.lightbend.lagom.scaladsl.api.ServiceLocator.NoServiceLocator
import com.lightbend.lagom.scaladsl.server._
import com.lightbend.lagom.scaladsl.devmode.LagomDevModeComponents
import play.api.libs.ws.ahc.AhcWSComponents
import api.FooService
import com.softwaremill.macwire._

class FooLoader extends LagomApplicationLoader {

  override def load(context: LagomApplicationContext): LagomApplication =
    new FooApplication(context) {
      override def serviceLocator = NoServiceLocator
    }

  override def loadDevMode(context: LagomApplicationContext): LagomApplication =
    new FooApplication(context) with LagomDevModeComponents
}

abstract class FooApplication(context: LagomApplicationContext)
  extends LagomApplication(context)
    with AhcWSComponents {

  override lazy val lagomServer = serverFor[FooService](wire[FooServiceImpl])

  Files.write(environment.getFile("target/reload.log").toPath, s"${new Date()} - reloaded\n".getBytes("utf-8"),
    StandardOpenOption.CREATE, StandardOpenOption.APPEND)
} 

//设置package包名称以及导入依赖的类
package fiddle.router.cache
import java.nio.file.{Files, Path, StandardOpenOption}

import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Future
import scala.util.Try

class FileCache(cacheDir: Path) extends Cache {
  cacheDir.toFile.mkdirs()

  override def get(id: String, expiration: Int): Future[Option[Array[Byte]]] = {
    val file = cacheDir.resolve(s"$id-$expiration").toFile
    Future {
      if(file.exists()) {
        if( (System.currentTimeMillis() - file.lastModified())/1000 < expiration) {
          Some(Files.readAllBytes(file.toPath))
        } else {
          // remove expired file
          Try(file.delete())
          None
        }
      } else {
        None
      }
    }
  }

  override def put(id: String, data: Array[Byte], expiration: Int): Future[Unit] = {
    val file = cacheDir.resolve(s"$id-$expiration")
    Future {
      Files.write(file, data, StandardOpenOption.CREATE)
    }
  }
} 

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

import org.apache.spark.rdd.RDD

import scala.sys.process._
import scala.language.postfixOps
import java.nio.file.{Files, Paths, StandardOpenOption}
import scala.reflect.ClassTag

object NativeJob {
    var counter: Integer = 0
}


abstract class NativeJob[T: ClassTag] extends Serializable {
    
    private val identifier : String = NativeJob.counter.toString
    protected var binaryPath = ""
    NativeJob.counter += 1
    

    def compile (source: String) = {
        println(s"Preparing to compile $source to binary")
        binaryPath = s"/tmp/nativejob$identifier.so"
        val res = ((s"g++ -fPIC -shared $source  -o $binaryPath") !!)
        print (res)

    }
    
    def apply (dataSet: RDD[T]) : RDD[T] = {
        // Distribute the binary to nodes
        if (binaryPath == "") {
            throw new Exception ("No binary found")
        }
        val binaryData = Files.readAllBytes(Paths.get(binaryPath))
        val broadcastFile = dataSet.context.broadcast(binaryData)
        val res = dataSet.mapPartitionsWithIndex ((i,iter) => {
            try {
                Files.write(Paths.get(binaryPath), broadcastFile.value, StandardOpenOption.CREATE, StandardOpenOption.WRITE)
                //(s"chmod +x /tmp/nativejob$identifier" !!)
                
            } catch {
                case e  : Throwable => throw new Exception ("Error writing binary to local filesystem")
            }
            applyPartition(i, iter)
        })
        res
    }

    def applyPartition (index: Integer, iter: Iterator[T]) : Iterator[T]


} 

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

import java.nio.file.{ Path, Paths }
import java.nio.file.StandardOpenOption
import java.nio.file.StandardOpenOption._
import java.time.ZonedDateTime
import java.time.format.DateTimeFormatter

import scala.concurrent.Future

import akka.actor.ActorSystem
import akka.stream.{ ActorMaterializer, IOResult }
import akka.stream.scaladsl._
import akka.util.ByteString

object GenerateLogFile extends App {
  val filePath = args(0)
  val numberOfLines = args(1).toInt
  val rnd = new java.util.Random()
  val sink = FileIO.toPath(FileArg.shellExpanded(filePath), Set(CREATE, WRITE, APPEND))
  def line(i: Int) = {
    val host = "my-host"
    val service = "my-service"
    val time = ZonedDateTime.now.format(DateTimeFormatter.ISO_INSTANT)
    val state = if( i % 10 == 0) "warning" 
      else if(i % 101 == 0) "error" 
      else if(i % 1002 == 0) "critical"
      else "ok"
    val description = "Some description of what has happened."
    val tag = "tag"
    val metric = rnd.nextDouble() * 100
    s"$host | $service | $state | $time | $description | $tag | $metric \n"
  }

  val graph = Source.fromIterator{() => 
    Iterator.tabulate(numberOfLines)(line)
  }.map(l=> ByteString(l)).toMat(sink)(Keep.right)

  implicit val system = ActorSystem() 
  implicit val ec = system.dispatcher
  implicit val materializer = ActorMaterializer()

  graph.run().foreach { result =>
    println(s"Wrote ${result.count} bytes to '$filePath'.")
    system.terminate()
  }  
} 

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

import java.io.File
import java.nio.file.{Files, StandardOpenOption}
import java.util.concurrent.atomic.AtomicInteger

class FileHandle(val file: File, append: Boolean) {
  val references = new AtomicInteger(0)

  // Make sure the directories exist
  file.getParentFile.mkdirs()

  private val writer = Files.newBufferedWriter(
    file.toPath,
    if (append) StandardOpenOption.APPEND else StandardOpenOption.TRUNCATE_EXISTING,
    StandardOpenOption.CREATE,
    StandardOpenOption.WRITE
  )

  def write(s: String, autoFlush: Boolean): Unit = {
    writer.write(s)
    if (autoFlush) {
      writer.flush()
    }
  }

  def close(): Unit = {
    writer.flush()
    writer.close()
  }
}

object FileHandle {
  private var map = Map.empty[File, FileHandle]

  def apply(file: File, append: Boolean): FileHandle = synchronized {
    val h = map.get(file) match {
      case Some(handle) => handle
      case None => {
        val handle = new FileHandle(file, append)
        map += file -> handle
        handle
      }
    }
    h.references.incrementAndGet()
    h
  }

  def release(handle: FileHandle): Unit = synchronized {
    handle.references.decrementAndGet()
    if (handle.references.get() == 0) {
      map -= handle.file
      handle.close()
    }
  }
}