Packages

•  package root

  Definition Classes

  root

•  package ca

  Definition Classes

  root

•  package dvgi

  Definition Classes

  ca

•  package managerial

  Managerial is a library for managing resource lifecycle monadically.

  Managerial is a library for managing resource lifecycle monadically.

  The main entry points to the library are found in Managed$.

  The following is a full-fledged usage example:

  import ca.dvgi.managerial.Managed
  import ca.dvgi.managerial._
  
  object Main extends App {
  
   val server = for {
     // create a Managed[Unit] for side effects
     _ <- Managed.eval(println("Starting setup..."))(println("Finished teardown"))
  
     // create Managed[Settings] that doesn't require teardown
     settings <- Managed.setup(Settings(8080, 7070))
  
     // create Managed[HealthCheckServer], which requires teardown
     healthCheckServer <- Managed(new HealthCheckServer(settings))(_.stop())
  
     // Managed#from expects a type class instance for Teardown[T], instead of having teardown specified explicitly.
     // ca.dvgi.managerial provides Teardown[AutoCloseable].
     apiServer <- Managed.from(new ApiServer(settings))
  
     // once the ApiServer is started, the HealthCheckServer can show it's ready
     _ <- Managed.eval(healthCheckServer.markReady())(healthCheckServer.markUnready())
  
     // evalSetup and evalTeardown allow for side-effects during only setup or only teardown
     _ <- Managed.evalSetup(println("Startup is finished!"))
   } yield apiServer
  
   // builds the Managed stack and registers a JVM shutdown hook to do automatic teardown
   server.useUntilShutdown()
  }
  
  case class Settings(healthCheckPort: Int, apiPort: Int)
  
  class HealthCheckServer(settings: Settings) {
   println("Started HealthCheckServer")
   def stop(): Unit = {
     println("Stopped HealthCheckServer")
   }
   def markReady(): Unit = println("Marked HealthCheckServer Ready")
   def markUnready(): Unit = println("Marked HealthCheckServer Unready")
  }
  
  class ApiServer(settings: Settings) extends AutoCloseable {
   import scala.concurrent.ExecutionContext.Implicits.global
   import scala.concurrent.duration.Duration
   import scala.concurrent.Await
   import scala.concurrent.Future
   val fakeServer = new Thread {
     override def run: Unit = {
       Await.ready(Future.never, Duration.Inf)
     }
   }
   fakeServer.start()
   println("Started ApiServer")
   def close(): Unit = {
     println("Stopped ApiServer")
   }
  }

ca

dvgi 