fitter

instalatur

Perpustakaan Manajemen Komponen Sistem untuk Clojure.

PERPUSTAKAAN TUJUAN SAMA:

• Komponen
• Yg merupakan bagian dr yg utuh
• gunung
• Injeksi ketergantungan

Tujuan desain

• Jelaskan dependensi komponen sistem di satu tempat.
• Mendeklarasikan komponen sistem semudah fungsi baru.
• Izinkan ketergantungan ad-hoc dan dinamis yang ditentukan oleh komponen itu sendiri.
• Cocok untuk sistem dengan jumlah komponen apa pun.
• Fleksibilitas maksimum untuk skenario apa pun.
• Bantu pengembang untuk beralasan tentang seluruh status sistem.

Terminologi

• contoh
  • Sesuatu yang bermanfaat Instantiated :-)
• komponen
  • Deskripsi cara menginisialisasi/menghancurkan instance.
• registri
  • Peta kunci dan komponen yang digunakan dalam operasi start/stop sistem.
• sistem
  • Koleksi instance komponen dependen.

Fitur

• Mulai/hentikan sistem komponen, semua komponen terdaftar atau hanya sebagian dari mereka.
• Tangguhkan/melanjutkan komponen pada restart sistem.
• Bind Component Instance ke Global VARS alias Mount (Opsional).
• Eksekusi paralel komponen selama sistem start/stop (opsional).

Penggunaan dasar

Deklarasi Komponen

Komponen minimal hanyalah sistem penerima fungsi "peta" dari instance komponen lainnya dan mengembalikan instance komponen ini. Sistem "peta" hanya mendukung antarmuka ILookup , lihat uji sistem. Semua pencarian membuat komponen yang diminta dan membentuk ketergantungan antara komponen secara dinamis. (!) Semua komponen secara ketat digabungkan bersama oleh nama kunci sistem.

Komponen lengkap mendefinisikan perilaku mulai, berhenti, dan menunda.

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

Status sistem

Status sistem adalah instance holding variabel dari komponen yang berjalan. Negara diinisialisasi oleh init dan kemudian diubah oleh start! Dan 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)))

Contoh

• Fitur: Mount
• Fitur: Paralel
• Fitur: Tangguhkan
• How-To: Tambahkan logging
• How-to: Komponen penggunaan kembali
• How-To: Validasi Spec