Téléchargement compost - Téléchargement du code source compost

compost

Composants tiers

1.0.0

Télécharger

Compost

Bibliothèque qui gère le cycle de vie des composants avec état. Ceci est une variation de l'idée du projet https://github.com/stuartsierra/component. À l'heure actuelle, cette bibliothèque ne prend pas en charge Clojurescript.

Usage

Ajoutez cette dépendance à votre projet

  [net.readmarks/compost "0.2.0"]

Voir les tests pour des exemples. La déclaration des composants a une forme

   { :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.

Tous les champs sont facultatifs, les défaillances sont:

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

:start et :stop doivent renvoyer une nouvelle valeur des composants :this . Si le composant acquiert des ressources :start il doit les libérer dans :stop . La déclaration du système est une carte simple

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

Exemple d'utilisation du cycle de vie

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

Vous pouvez récupérer l'état du système actuel après exception comme suit:

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

Les aides à la gestion des erreurs

Cette fonctionnalité est implémentée par Net.Readmarks. Cet espace de noms est considéré comme expérimental, son contenu pourrait changer dans n'importe quelle version.

L'agent ("gardien") détient l'état actuel du système ainsi que les exceptions du cycle de vie. L'exemple d'utilisation:

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

Utilisation de composants com.stuartsierra.

Vous pouvez adapter les composants existants comme suit:

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

Notez que, contrairement à com.stuartierra.component, la séquence de nrcompost/stop peut différer du startup inverse. Seules les dépendances déclarées explicitement sont respectées. Si vous devez tenir compte des dépendances implicites, vous devez ajouter des éléments supplémentaires aux composants :require des collections.

Motivation

J'aime ce que fournit le composant mais je veux aussi

Utilisez n'importe quelle valeur comme composant. Par exemple, je veux qu'une fermeture de fonction soit un composant. Ou, alternativement, un composant est visible en fonction. En plus de cela, je n'aime pas l'idée de toujours garder la référence de dépendance même si elle pourrait être nécessaire uniquement dans la fonction de démarrage.
Ne nécessite pas de nouveau type pour chaque composant. La mise en œuvre Lifecycle gêne lorsque vous n'avez besoin que d'un composant ad hoc. L'obligation de composante est également une carte et implémenter le cycle de vie restreint efficacement le composant comme un enregistrement. Cela signifie également que parfois les gens recourent à des travaux de travail pour éviter de créer de nouveaux types.
Utilisez des structures de données Clojure simples pour configurer le système. Je pense que mettre la configuration dans les métadonnées était une erreur. Au lieu de rationaliser, cela complique en fait le code. La configuration du système est également des données que l'on pourrait vouloir inspecter ou modifier. Donnez-lui des droits égaux :)
Soyez compatible avec les composants com.stuartsierra. Il y a déjà beaucoup de ces composants et c'est une bonne chose. Cette pièce ne doit nécessiter qu'une petite quantité de code de colle.