Descarga compost - Descarga del código fuente compost

compost

Componentes de terceros

1.0.0

Descargar

Compost

Biblioteca que administra el ciclo de vida de los componentes con estado. Esta es una variación de https://github.com/stuartsierra/Component Project. Por el momento, esta biblioteca no admite Clojurescript.

Uso

Agregue esta dependencia a su proyecto

  [net.readmarks/compost "0.2.0"]

Ver pruebas para ver ejemplos. La declaración de componentes tiene forma

   { :requires #{ :required-component-id-1 :required-component-id-2 }}
    :this initial-state
    :get ( fn [this] ...) ; ; Returns value of this component that other components will get as dependency. 
    :start ( fn [this dependency-components-map] ...) ; ; Acquire resources (open connections, start threads ...)
    :stop ( fn [this] ...)} ; ; Release resources.

Todos los campos son opcionales, los valores predeterminados son:

   { :requires #{}
    :this nil
    :get identity 
    :start ( fn [this dependency-components-map] this)
    :stop identity}

:start y :stop deben devolver un nuevo valor de los componentes :this . Si el componente adquiere recursos en :start , debe liberarlos en :stop . La declaración del sistema es un mapa simple

  { :component-1-id component-1-declaration
   :component-2-id component-2-declaration
   ...
  }

Ejemplo de uso del ciclo de vida

 ( require '[net.readmarks.compost :as compost])
 ( let [s ( compost/start system-map #{ :web-component :some-worker-component })]
   ( Thread/sleep 5000 )
   ( compost/stop s))

Puede salvar el estado actual del sistema tras excepción de la siguiente manera:

 ( try
   ( compost/start system-map)
   ( catch ExceptionInfo ex
     ( if-let [sys ( compost/ex-system ex)]
       ( compost/stop sys) ; ;; Handle this system as desired here.
       ( throw ex))))

Ayudantes de manejo de errores

Esta característica es implementada por net.readmarks.compost.eper NameSpace. Este espacio de nombres se considera experimental, su contenido podría cambiar en cualquier versión.

El agente ("Keeper") posee el estado actual del sistema junto con las excepciones de Lifecycle. El ejemplo de uso:

 ( require '[net.readmarks.compost :as compost])
 ( require '[net.readmarks.compost.keeper :as keeper])

 ( def sys ( keeper/keeper system-map))

 ( keeper/update-keeper! sys compost/start)
 ; ; Now sys holds current system value and errors if there are any.
 ; ; (:system @sys) is current system map value.
 ; ; (:errors @sys) is list of of system lifecycle errors. It is empty if system changes were successful.

 ; ; You can send these errors into a log, for example:
 ( keeper/flush-errors! sys println) ; ; The function gets errors one by one.

Usando com.stuartsierra.com componentes

Puede adaptar los componentes existentes de la siguiente manera:

( defn component-using [init using]
  { :requires ( set using)
   :this init
   :start ( fn [this deps]
            ( -> ( merge this deps)
                component/start)
   :stop component/stop})
 
( def system 
  { :conn-source ( component-using
                   ( ->MyConnPool )
                   [])
   :dao ( component-using
          ( map->MyDbComponent {})
          [ :conn-source ])}

Tenga en cuenta que, a diferencia de com.stuartsierra.Component La secuencia de nrcompost/stop podría diferir del inicio inverso uno. Solo se respetan las dependencias declaradas explícitamente. Si necesita tener en cuenta las dependencias implícitas, debe agregar elementos adicionales a los componentes :require colecciones.

Motivación

Me gusta lo que proporciona el componente pero también quiero

Use cualquier valor como componente. Por ejemplo, a menudo quiero que un cierre de la función sea un componente. O, alternativamente, un componente será visible como una función. Además de esto, no me gusta la idea de mantener siempre la referencia de dependencia a pesar de que solo podría ser necesaria en la función inicial.
No requiere un nuevo tipo para cada componente. La implementación Lifecycle se interpone en el camino cuando solo necesita un componente ad hoc. También el requisito para que el componente sea un mapa e implementar el ciclo de vida restringe efectivamente el componente para que sea un registro. Esto también significa que a veces las personas recurren a la solución al trabajo para evitar crear nuevos tipos.
Use estructuras de datos de Clojure simples para configurar el sistema. Creo que poner la configuración en metadatos fue un error. En lugar de racionalizarlo, realmente complica el código. La configuración del sistema también son datos que uno puede querer inspeccionar o modificar. Dale igual derecho :)
Ser compatible con com.stuartsierra.component/Lifecycle Components. Ya hay muchos de esos componentes y esto es algo bueno. Esta parte debe requerir solo una pequeña cantidad de código de pegamento.