Configuration Service

libraryDependencies += "com.github.tmtsoftware.csw" %% "csw-config-client" % "5.0.1"

copysource// config client API
val clientApi: ConfigClientService = ConfigClientFactory.clientApi(actorSystem, locationService)
// config admin API
val adminApi: ConfigService = ConfigClientFactory.adminApi(actorSystem, locationService, factory)

copysource// construct the path
val filePath = Paths.get("/tmt/trmobone/assembly/hcd.conf")

val doneF = async {
  // create file using admin API
  await(adminApi.create(filePath, ConfigData.fromString(defaultStrConf), annex = false, "First commit"))

  // check if file exists with config service
  val exists: Boolean = await(clientApi.exists(filePath))
  // exists returns true/false

copysourceval defaultStrConf: String = "foo { bar { baz : 1234 } }"
val doneF = async {
  // construct the path
  val filePath = Paths.get("/tmt/trmobone/assembly/hcd.conf")

  await(adminApi.create(filePath, ConfigData.fromString(defaultStrConf), annex = false, "First commit"))

  val activeFile: Option[ConfigData] = await(clientApi.getActive(filePath))
  // activeFile.get returns content of defaultStrConf

copysourceasync {
  // construct ConfigData from String containing ASCII text
  val configString: String =
    """
  // Name: ComponentType ConnectionType
  {
    name: lgsTromboneHCD
    type: Hcd
    connectionType: [akka]
  }
  """.stripMargin
  val config1: ConfigData = ConfigData.fromString(configString)

  // construct ConfigData from a local file containing binary data
  val srcFilePath         = ResourceReader.copyToTmp("/smallBinary.bin")
  val config2: ConfigData = ConfigData.fromPath(srcFilePath)

  // construct ConfigData from Array[Byte] by reading a local file
  val stream: InputStream    = getClass.getClassLoader.getResourceAsStream("smallBinary.bin")
  def byteArray: Array[Byte] = LazyList.continually(stream.read).takeWhile(_ != -1).map(_.toByte).toArray
  val config3                = ConfigData.fromBytes(byteArray)

  // store the config, at a specified path as normal text file
  val id1: ConfigId =
    await(adminApi.create(Paths.get("/hcd/trombone/overnight.conf"), config1, annex = false, "review done"))

  // store the config, at a specified path as a binary file in annex store
  val id2: ConfigId =
    await(adminApi.create(Paths.get("/hcd/trombone/firmware.bin"), config2, annex = true, "smoke test done"))

  // store the config, at a specified path as a binary file in annex store
  val id3: ConfigId =
    await(adminApi.create(Paths.get("/hcd/trombone/debug.bin"), config3, annex = true, "new file from vendor"))
  // id1 returns ConfigId(1)
  // id2 returns ConfigId(3)
  // id3 returns ConfigId(5)

copysourceval futU = async {
  val destPath = Paths.get("/hcd/trombone/debug.bin")
  val newId = await(
    adminApi
      .update(destPath, ConfigData.fromString(defaultStrConf), comment = "debug statements")
  )
  // newId returns ConfigId(7)

copysourceval futD = async {
  val unwantedFilePath = Paths.get("/hcd/trombone/debug.bin")
  await(adminApi.delete(unwantedFilePath, "no longer needed"))
  // validates the file is deleted
  val maybeConfigData = await(adminApi.getLatest(unwantedFilePath))
  // maybeConfigData returns None

copysourceval doneF = async {
  // create a file using API first
  val filePath = Paths.get("/tmt/trmobone/assembly/hcd.conf")
  val id: ConfigId =
    await(adminApi.create(filePath, ConfigData.fromString(defaultStrConf), annex = false, "First commit"))

  // validate
  val actualData = await(adminApi.getById(filePath, id)).get
  // actualData returns defaultStrConf

copysourceval assertionF: Future[Assertion] = async {
  // create a file
  val filePath = Paths.get("/test.conf")
  await(adminApi.create(filePath, ConfigData.fromString(defaultStrConf), annex = false, "initial configuration"))

  // override the contents
  val newContent = "I changed the contents!!!"
  await(adminApi.update(filePath, ConfigData.fromString(newContent), "changed!!"))

  // get the latest file
  val newConfigData = await(adminApi.getLatest(filePath)).get
  // validate
  // newConfigData returns newContent

copysourceval assertionF = async {
  val tInitial = Instant.MIN
  // create a file
  val filePath = Paths.get("/a/b/c/test.conf")
  await(adminApi.create(filePath, ConfigData.fromString(defaultStrConf), annex = false, "initial configuration"))

  // override the contents
  val newContent = "I changed the contents!!!"
  await(adminApi.update(filePath, ConfigData.fromString(newContent), "changed!!"))

  val initialData: ConfigData = await(adminApi.getByTime(filePath, tInitial)).get
  // initialData returns defaultStrConf

  val latestData = await(adminApi.getByTime(filePath, Instant.now())).get
  // latestData returns defaultStrConf

copysource// Here's a list of tuples containing FilePath and FileTyepe(Annex / Normal)
val paths: List[(Path, FileType)] = List[(Path, FileType)](
  (Paths.get("a/c/trombone.conf"), Annex),
  (Paths.get("a/b/c/hcd/hcd.conf"), Normal),
  (Paths.get("a/b/assembly/assembly1.fits"), Annex),
  (Paths.get("a/b/c/assembly/assembly2.fits"), Normal),
  (Paths.get("testing/test.conf"), Normal)
)

// create config files at those paths
paths map { case (path, fileType) =>
  val createF = async {
    await(
      adminApi.create(path, ConfigData.fromString(defaultStrConf), Annex == fileType, "initial commit")
    )
  }
}

val responsesF = async {
  // retrieve list of all files;
  val allFilesF = await(adminApi.list()).map(info => info.path).toSet

  // retrieve list of files based on type;
  val allAnnexFilesF  = await(adminApi.list(Some(Annex))).map(info => info.path).toSet
  val allNormalFilesF = await(adminApi.list(Some(FileType.Normal))).map(info => info.path).toSet

  // retrieve list using pattern;
  val confFilesByPatternF = await(adminApi.list(None, Some(".*.conf"))).map(info => info.path.toString).toSet

  // retrieve list using pattern and file type;
  val allNormalConfFilesF = await(adminApi.list(Some(FileType.Normal), Some(".*.conf"))).map(info => info.path.toString).toSet

  val testConfF          = await(adminApi.list(Some(FileType.Normal), Some("test.*"))).map(info => info.path.toString).toSet
  val allAnnexConfFilesF = await(adminApi.list(Some(Annex), Some("a/c.*"))).map(info => info.path.toString).toSet

copysourceval assertionF = async {
  val filePath = Paths.get("/a/test.conf")
  val id0      = await(adminApi.create(filePath, ConfigData.fromString(defaultStrConf), annex = false, "first commit"))

  // override the contents twice
  val tBeginUpdate = Instant.now()
  val id1          = await(adminApi.update(filePath, ConfigData.fromString("changing contents"), "second commit"))
  val id2          = await(adminApi.update(filePath, ConfigData.fromString("changing contents again"), "third commit"))
  val tEndUpdate   = Instant.now()

  // full file history
  val fullHistory = await(adminApi.history(filePath))

  // drop initial revision and take only update revisions
  val revisionsBetweenF = await(adminApi.history(filePath, tBeginUpdate, tEndUpdate)).map(_.id)

  // take last two revisions
  val last2RevisionsF = await(adminApi.history(filePath, maxResults = 2)).map(_.id)

copysourceval assertionF = async {
  val tBegin   = Instant.now()
  val filePath = Paths.get("/a/test.conf")
  // create will make the 1st revision active with a default comment
  val id1      = await(adminApi.create(filePath, ConfigData.fromString(defaultStrConf), annex = false, "first"))
  val activeId = await(adminApi.historyActive(filePath)).map(_.id)

  // ensure active version is set
  val activeVersionF = await(adminApi.getActiveVersion(filePath)).get

  // override the contents four times
  await(adminApi.update(filePath, ConfigData.fromString("changing contents"), "second"))
  val id3 = await(adminApi.update(filePath, ConfigData.fromString("changing contents again"), "third"))
  val id4 = await(adminApi.update(filePath, ConfigData.fromString("final contents"), "fourth"))
  val id5 = await(adminApi.update(filePath, ConfigData.fromString("final final contents"), "fifth"))

  // update doesn't change the active revision
  val idList = await(adminApi.historyActive(filePath)).map(_.id)
  // play with active version
  await(adminApi.setActiveVersion(filePath, id3, s"$id3 active"))
  await(adminApi.setActiveVersion(filePath, id4, s"$id4 active"))
  val id4F = await(adminApi.getActiveVersion(filePath)).get
  val tEnd = Instant.now()
  // reset active version to latest
  await(adminApi.resetActiveVersion(filePath, "latest active"))
  val id5F = await(adminApi.getActiveVersion(filePath)).get

  // finally set initial version as active
  await(adminApi.setActiveVersion(filePath, id1, s"$id1 active"))
  val id1F = await(adminApi.getActiveVersion(filePath)).get

  //  get full history
  val fullHistory = await(adminApi.historyActive(filePath))

  // drop initial revision and take only update revisions
  val fragmentedHistory = await(adminApi.historyActive(filePath, tBegin, tEnd))

  // take last three revisions
  val last3Revisions = await(adminApi.historyActive(filePath, maxResults = 3)).map(_.id)

  // get contents of active version at a specified instance
  val initialContents       = await(adminApi.getActiveByTime(filePath, tBegin)).get
  val initialContentsParseF = await(initialContents.toStringF(actorSystem))

copysourceval assertF = async {
  val metaData: ConfigMetadata = await(adminApi.getMetadata)
  //  metaData.repoPath returns repository path