fitter

Monteur

Systemkomponentenverwaltungsbibliothek für Clojure.

Ähnliche Zweckbibliotheken:

• Komponente
• Integrant
• montieren
• Abhängigkeitsinjektion

Designziele

• Beschreiben Sie die Abhängigkeiten der Systemkomponenten an einem Ort.
• Deklarieren Sie die Systemkomponenten so einfach wie neue Funktion.
• Lassen Sie Ad-hoc- und dynamische Abhängigkeiten zulassen, die durch Komponenten selbst definiert sind.
• Fit für Systeme mit einer beliebigen Anzahl von Komponenten.
• Maximale Flexibilität für jedes Szenario.
• Helfen Sie dem Entwickler, über den gesamten Systemzustand zu argumentieren.

Terminologie

• Beispiel
  • etwas Nützliches instanziiert :-)
• Komponente
  • Die Beschreibung, wie Sie Instanz initialisieren/zerstören.
• Registrierung
  • Karte von Schlüsseln und Komponenten, die in Systemstart-/Stoppvorgängen verwendet werden.
• System
  • Sammlung abhängiger Komponenteninstanzen.

Merkmale

• Start/Stoppsystem von Komponenten, allen registrierten Komponenten oder nur einem Teil von ihnen.
• Komponenten aussetzen/Lebenslauf beim System Neustart.
• Binden Sie Komponenteninstanzen an globale VARS -AKA -Mount (optional).
• Parallele Ausführung von Komponenten während des Systems Start/Stopp (optional).

Grundnutzung

Komponentenerklärung

Minimale Komponente ist nur eine Funktion empfangsem System „Karte“ anderer Komponenteninstanzen und der Rückgabe dieser Komponenteninstanz. Das System „MAP“ unterstützt nur ILookup Schnittstelle, siehe Systemtest. Alle Lookups instanziieren angeforderte Komponenten und bilden dynamisch eine Abhängigkeit zwischen Komponenten. (!) Alle Komponenten sind durch Systemschlüsselnamen eng zusammengekoppelt.

Die vollständige Komponente definiert das Verhalten von Start, Stopp und Suspend.

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

Systemzustand

Der Systemzustand ist eine variable Halteinstanzen der laufenden Komponenten. Der Staat wird durch init initialisiert und dann durch start! Und 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)))

Beispiele

• Feature: Mount
• Feature: Parallel
• Feature: Suspend
• Anleitungen: Protokollierung hinzufügen
• Anleitungen: Komponenten wiederverwenden
• Anleitungen: Spezifikation validieren