fitter

installateur

Bibliothèque de gestion des composants système pour Clojure.

Bibliothèques à usage similaire:

• Composant
• Intégrant
• monter
• Injection de dépendance

Objectifs de conception

• Décrivez les dépendances des composants du système à la seule place.
• Déclarez les composants du système aussi simples que la nouvelle fonction.
• Autorisez les dépendances ad hoc et dynamiques définies par les composants eux-mêmes.
• Ajustement pour les systèmes avec n'importe quelle quantité de composants.
• Flexibilité maximale pour tout scénario.
• Aidez le développeur à raisonner sur l'ensemble de l'état du système.

Terminologie

• exemple
  • Quelque chose d'utile instancié :-)
• composant
  • La description comment initialiser / détruire l'instance.
• enregistrement
  • Carte des clés et des composants utilisés dans les opérations de démarrage / arrêt du système.
• système
  • Collection d'instances de composants dépendantes.

Caractéristiques

• Système de démarrage / arrêt des composants, tous les composants enregistrés ou une seule partie d'entre eux.
• Suspendre / CV Composants sur le redémarrage du système.
• Lier les instances des composants à Global Vars aka Mount (facultatif).
• Exécution parallèle des composants pendant le démarrage / arrêt du système (facultatif).

Utilisation de base

Déclaration des composants

Le composant minimal n'est qu'une fonction de réception de fonction «Map» du système d'autres instances de composant et renvoyant cette instance de composante. Le système «Map» ne prend en charge que l'interface ILookup , voir le test du système. Toutes les recherches instancient des composants demandés et forment une dépendance entre les composants dynamiquement. (!) Tous les composants sont étroitement couplés par des noms de clés système.

Le composant complet définit son comportement de début, d'arrêt et de suspension.

( ns readme.component
  ( :require [strojure.fitter.component :as component]))

( def function-component
  " Simple function describes component start behaviour. "
  ( fn [{ :keys [another-component]}]
    ( comment " Use " another-component)
    :instance ))

( def constant-component
  " Just constant component. "
  ( constantly true ))

( def map-component
  " Component described as hash map with required `::component/start` key. "
  { ::component/start ( constantly :instance )
   ::component/stop! ( fn stop! [instance]
                       ( comment " Destroy " instance))
   ::component/suspend! ( fn suspend! [old-instance old-system]
                          ( comment " Suspend " old-instance old-system)
                          ( fn resume [new-system]
                            ( comment " Resume " old-instance new-system)
                            :instance ))})

( def assembled-component
  " Same map as above created using `component/of`. "
  ( component/of ( constantly :instance )
                ( fn stop! [instance]
                  ( comment " Destroy " instance))
                ( fn suspend! [old-instance old-system]
                  ( comment " Suspend " old-instance old-system)
                  ( fn resume [new-system]
                    ( comment " Resume " old-instance new-system)
                    :instance ))))

État du système

L'état du système est une variable de maintien des instances des composants en cours d'exécution. L'état est initialisé par init puis modifié par start! Et stop! .

( ns readme.system-state
  ( :require [strojure.fitter.system :as system]))

( def ^:private registry
  { ::a ( constantly ::a )
   ::b ( fn [{ ::keys [a]}] { ::b a})})

; ; Initialize system state.
( defonce ^:private system!
  ( system/init { :registry registry}))

; ; Start all system keys.
( system/start! system!)

; ; Stop all running keys.
( system/stop! system!)

; ; The `start!`, `stop!` and `deref` return the actual system map. 
( let [{ ::keys [a b]} ( system/start! system!)]
  ( comment " Work with " a b))
( let [_ ( system/start! system!)
      { ::keys [a b]} ( deref system!)]
  ( comment " Work with " a b))

; ; Start/stop only specific keys.
( system/start! system! { :filter-keys #{ ::a }})
( system/stop! system! { :filter-keys #{ ::a }})

; ; Start/stop system incrementally.
( doto system! ( system/start! { :filter-keys #{ :a }})
              ( system/start! { :filter-keys ( complement #{ :a })}))
( doto system! ( system/stop! { :filter-keys ( complement #{ :a })})
              ( system/stop! { :filter-keys #{ :a }}))

; ; Update registry on start.
( system/start! system! { :registry ( assoc registry ::c ( constantly ::c ))})

; ; Suspend suspendable components on stop and resume them on start.
( doto system! ( system/stop! { :suspend true })
              ( system/start! ))

; ; Execute components in parallel
( doto ( system/init { :parallel true }) ( system/start! )
                                     ( system/stop! ))
( system/start! system! { :parallel true })
( system/stop! system! { :parallel true })

; ; Use `with-open` to stop system automatically.
( with-open [s! ( system/init { :registry registry})]
  ( let [{ ::keys [a b]} ( system/start! s!)]
    ( comment " Work with " a b)))

Exemples

• Caractéristique: monte
• Caractéristique: parallèle
• Caractéristique: suspendre
• Comment être: ajouter la journalisation
• PRouvreté: réutiliser les composants
• Comment faire: valider les spécifications