Config files

.gitignore

@@ -5,6 +5,7 @@ target/
 
 ### Environment file for local variables
 .env
+config/
 
 *.txt
 

build.sbt

@@ -19,6 +19,7 @@ val scalamockVersion = "5.2.0"
 val scalatestVersion = "3.2.17"
 val shapelessVersion = "2.3.10"
 val slf4jVersion = "2.0.9"
+val snakeYamlVersion = "2.0"
 val vaultVersion = "3.5.0"
 
 libraryDependencies ++= Seq(
@@ -40,6 +41,7 @@ libraryDependencies ++= Seq(
  "org.typelevel" %% "vault" % vaultVersion,
  "io.circe" %% "circe-generic" % circeVersion,
  "io.circe" %% "circe-generic-extras" % circeGenericExtrasVersion,
+ "org.yaml" % "snakeyaml" % snakeYamlVersion,
  "io.circe" %% "circe-parser" % circeVersion % Test,
  "org.scalamock" %% "scalamock" % scalamockVersion % Test,
  "org.scalatest" %% "scalatest" % scalatestVersion % Test

docker/Dockerfile

@@ -2,11 +2,9 @@ FROM hseeberger/scala-sbt:eclipse-temurin-11.0.14.1_1.6.2_2.13.8 as build
 
 WORKDIR /app
 
-COPY / /
-RUN sbt update
+COPY . .
 
-COPY .. .
-RUN sbt compile stage
+RUN sbt update compile stage
 
 FROM openjdk:11-jre-slim
 

src/main/resources/config-template.yaml

@@ -0,0 +1,40 @@
+## Watchlistarr Configuration
+## If you want to specify your own configuration, copy this file, and rename it to 'config.yaml'
+
+## How often do you want Watchlistarr to pull the latest from Plex?
+## In general, 10 seconds is okay.
+## If you're running this on a slower system (e.g. Raspberry Pi), you may want to increase this to 60 seconds.
+interval:
+ seconds: 60
+
+## Sonarr Configuration
+sonarr:
+ #baseUrl: "127.0.0.1:8989"
+ #apikey: "YOUR-API-KEY"
+ #qualityProfile: "Your Desired Sonarr Quality Profile"
+ #rootFolder: "/root/folder/location"
+ bypassIgnored: false
+ seasonMonitoring: all # Possible values under 'MonitorTypes' in sonarr.tv/docs/api
+ tags:
+ - watchlistarr
+
+## Radarr Configuration
+radarr:
+ #baseUrl: "127.0.0.1:7878"
+ #apikey: "YOUR-API-KEY"
+ #qualityProfile: "Your Desired Radarr Quality Profile"
+ #rootFolder: "/root/folder/location"
+ bypassIgnored: false
+ tags:
+ - watchlistarr
+
+## Plex Configuration
+plex:
+ #token: "YOUR-PLEX-TOKEN"
+ skipfriendsync: false # Don't sync friends watchlists, only your own
+
+delete:
+ movie: false
+ endedShow: false
+ continuingShow: false
+ interval.days: 7

src/main/scala/Server.scala

@@ -1,7 +1,7 @@
 
 import cats.effect._
 import cats.implicits.catsSyntaxTuple3Parallel
-import configuration.{Configuration, ConfigurationUtils, SystemPropertyReader}
+import configuration.{Configuration, ConfigurationUtils, FileAndSystemPropertyReader, SystemPropertyReader}
 import http.HttpClient
 import org.slf4j.LoggerFactory
 
@@ -18,40 +18,44 @@ object Server extends IOApp {
  }
 
  def run(args: List[String]): IO[ExitCode] = {
- val configReader = SystemPropertyReader
+ val configReader = FileAndSystemPropertyReader
  val httpClient = new HttpClient
 
  for {
- memoizedConfigIo <- ConfigurationUtils.create(configReader, httpClient).memoize
+ initialConfig <- ConfigurationUtils.create(configReader, httpClient)
+ configRef <- Ref.of[IO, Configuration](initialConfig)
  result <- (
- pingTokenSync(memoizedConfigIo, httpClient),
- plexTokenSync(memoizedConfigIo, httpClient),
- plexTokenDeleteSync(memoizedConfigIo, httpClient)
+ pingTokenSync(configRef, httpClient),
+ plexTokenSync(configRef, httpClient),
+ plexTokenDeleteSync(configRef, httpClient)
  ).parTupled.as(ExitCode.Success)
  } yield result
  }
 
- private def pingTokenSync(configIO: IO[Configuration], httpClient: HttpClient): IO[Unit] =
+ private def fetchLatestConfig(configRef: Ref[IO, Configuration]): IO[Configuration] =
+ configRef.get
+
+ private def pingTokenSync(configRef: Ref[IO, Configuration], httpClient: HttpClient): IO[Unit] =
  for {
- config <- configIO
+ config <- fetchLatestConfig(configRef)
  _ <- PingTokenSync.run(config, httpClient)
  _ <- IO.sleep(24.hours)
- _ <- pingTokenSync(configIO, httpClient)
+ _ <- pingTokenSync(configRef, httpClient)
  } yield ()
 
- private def plexTokenSync(configIO: IO[Configuration], httpClient: HttpClient, firstRun: Boolean = true): IO[Unit] =
+ private def plexTokenSync(configRef: Ref[IO, Configuration], httpClient: HttpClient, firstRun: Boolean = true): IO[Unit] =
  for {
- config <- configIO
+ config <- fetchLatestConfig(configRef)
  _ <- PlexTokenSync.run(config, httpClient, firstRun)
  _ <- IO.sleep(config.refreshInterval)
- _ <- plexTokenSync(configIO, httpClient, firstRun = false)
+ _ <- plexTokenSync(configRef, httpClient, firstRun = false)
  } yield ()
 
- private def plexTokenDeleteSync(configIO: IO[Configuration], httpClient: HttpClient): IO[Unit] =
+ private def plexTokenDeleteSync(configRef: Ref[IO, Configuration], httpClient: HttpClient): IO[Unit] =
  for {
- config <- configIO
+ config <- fetchLatestConfig(configRef)
  _ <- PlexTokenDeleteSync.run(config, httpClient)
  _ <- IO.sleep(config.deleteConfiguration.deleteInterval)
- _ <- plexTokenDeleteSync(configIO, httpClient)
+ _ <- plexTokenDeleteSync(configRef, httpClient)
  } yield ()
 }

src/main/scala/configuration/FileAndSystemPropertyReader.scala

@@ -0,0 +1,83 @@
+package configuration
+
+import org.slf4j.LoggerFactory
+import org.yaml.snakeyaml.Yaml
+
+import java.io.{File, FileInputStream}
+import java.nio.file.{Files, Paths, StandardCopyOption}
+import java.util
+import scala.jdk.CollectionConverters.{ListHasAsScala, MapHasAsScala}
+
+object FileAndSystemPropertyReader extends ConfigurationReader {
+
+ private val logger = LoggerFactory.getLogger(getClass)
+
+ private lazy val data: Map[String, String] = {
+ val yaml = new Yaml()
+ val configDirPath = "config"
+ val configFile = new File(s"$configDirPath/config.yaml")
+
+ try {
+ // Ensure parent config folder exists
+ val parentDir = configFile.getParentFile
+ if (!parentDir.exists()) parentDir.mkdirs()
+
+ if (!configFile.exists()) {
+ val resourceStream = getClass.getClassLoader.getResourceAsStream("config-template.yaml")
+ if (resourceStream != null) {
+ try {
+ Files.copy(resourceStream, Paths.get(configFile.toURI), StandardCopyOption.REPLACE_EXISTING)
+ logger.info(s"Created config file in ${configFile.getPath}")
+ } finally {
+ resourceStream.close()
+ }
+ } else {
+ logger.debug("config-template.yaml resource not found")
+ }
+ }
+
+ if (configFile.exists()) {
+ val inputStream = new FileInputStream(configFile)
+ val result = yaml.load[util.Map[String, Object]](inputStream).asScala
+ inputStream.close()
+ flattenYaml(Map.from(result))
+ } else {
+ Map.empty[String, String]
+ }
+ } catch {
+ case e: Exception =>
+ logger.debug(s"Failed to read from config.yaml: ${e.getMessage}")
+ Map.empty[String, String]
+ }
+ }
+
+ override def getConfigOption(key: String): Option[String] =
+ if (data.contains(key))
+ data.get(key)
+ else
+ SystemPropertyReader.getConfigOption(key)
+
+ private def flattenYaml(yaml: Map[String, _]): Map[String, String] = yaml.flatMap {
+ case (k, v: util.ArrayList[_]) =>
+ List((k, v.asScala.mkString(",")))
+
+ case (k, v: String) =>
+ List((k, v))
+
+ case (k, v: Integer) =>
+ List((k, v.toString))
+
+ case (k, v: java.lang.Boolean) =>
+ List((k, v.toString))
+
+ case (k, v: util.LinkedHashMap[String, _]) =>
+ val flattenedInner = flattenYaml(Map.from(v.asScala))
+ flattenedInner.map { case (innerK, innerV) =>
+ (s"$k.$innerK", innerV)
+ }.toList
+
+ case (k, v) =>
+ logger.warn(s"Unhandled config pair of type: ${k.getClass} -> ${v.getClass}")
+ List((k, v.toString))
+ }
+}

src/main/scala/configuration/SystemPropertyReader.scala

@@ -1,5 +1,5 @@
 package configuration
 
 object SystemPropertyReader extends ConfigurationReader {
- def getConfigOption(key: String): Option[String] = Option(System.getProperty(key))
+ override def getConfigOption(key: String): Option[String] = Option(System.getProperty(key))
 }