Download compost - Download de código fonte compost

compost

Componentes de terceiros

1.0.0

Baixar

Composto

Biblioteca que gerencia o ciclo de vida dos componentes com estado. Esta é uma variação de https://github.com/stuartsierra/component Project IDEA. No momento, essa biblioteca não suporta CloJurescript.

Uso

Adicione esta dependência ao seu projeto

  [net.readmarks/compost "0.2.0"]

Veja testes para exemplos. A declaração de componente tem 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 os campos são opcionais, os padrões são:

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

:start e :stop devem retornar o novo valor dos componentes :this . Se o componente adquirir recursos em :start ele deve liberá -los em :stop . A declaração do sistema é um mapa simples

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

Exemplo de uso do 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))

Você pode salvar o estado do sistema atual após a exceção da seguinte forma:

 ( 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))))

Erros de manuseio de ajudantes

Esse recurso é implementado por Net.readmarks.compost.keeper namespace. Esse espaço para nome é considerado experimental, seu conteúdo pode mudar em qualquer versão.

O agente ("Keeper") mantém o estado atual do sistema, juntamente com as exceções do ciclo de vida. O exemplo 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 componentes com.stuartsierra.component

Você pode adaptar os componentes existentes da seguinte forma:

( 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 ])}

Observe que, diferentemente do com.stuartsierra.componente, a sequência do nrcompost/stop pode diferir da inicialização reversa de um. Somente dependências declaradas explicitamente são respeitadas. Se você precisar contabilizar dependências implícitas, adicione elementos adicionais aos componentes :require coleções.

Motivação

Eu gosto do que o componente oferece, mas também quero

Use qualquer valor como componente. Por exemplo, muitas vezes eu quero um fechamento de função para ser um componente. Ou, alternativamente, um componente será visível como uma função. Além disso, não gosto da idéia de manter sempre a referência de dependência, mesmo que possa ser necessária apenas na função de início.
Não requer um novo tipo para cada componente. A implementação Lifecycle atrapalha quando você precisa apenas de um componente ad hoc. O requisito também para que o componente seja um mapa e implemente o ciclo de vida efetivamente restrinja o componente a ser um registro. Isso também significa que, às vezes, as pessoas recorrem a articulações para evitar a criação de novos tipos.
Use estruturas de dados de clojure simples para configurar o sistema. Eu acho que colocar a configuração em metadados foi um erro. Em vez de simplificá -lo, na verdade complica o código. A configuração do sistema também são dados que se pode querer inspecionar ou modificar. Dê direitos iguais :)
Seja compatível com com.stuartsierra.component/LifeCycle Components. Já existem muitos desses componentes e isso é uma coisa boa. Esta parte deve exigir apenas uma pequena quantidade de código de cola.