fitter下载 - fitter源代码下载

fitter

三方组件

1.0.0

下载

钳工

系统组件管理库，用于Clojure。

类似的目的库：

成分
整合物
山
依赖注入

设计目标

描述单个位置的系统组件依赖性。
声明系统组件与新功能一样容易。
允许由组件本身定义的临时和动态依赖性。
适合具有多种组件的系统。
任何场景的最大灵活性。
帮助开发人员推理整个系统状态。

术语

实例
- 实例有用的东西:-)
成分
- 描述如何初始化/破坏实例。
注册表
- 系统开始/停止操作中使用的密钥和组件图。
系统
- 收集因组件实例。

特征

启动/停止组件，所有注册组件或仅部分组件。
系统重新启动上的暂停/简历组件。
将组件实例绑定到全局vars aka安装座（可选）。
系统启动/停止期间的组件的并行执行（可选）。

基本用法

组件声明

最小组件只是其他组件实例的“映射”功能，并返回此组件实例。系统“映射”仅支持ILookup接口，请参见系统测试。所有查找都实例化了请求的组件，并动态地在组件之间形成依赖性。（！）所有组件都通过系统关键名称紧密结合在一起。

完整的组件定义其开始，停止和暂停行为。

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

系统状态

系统状态是运行组件的变量保存实例。该状态是通过init初始化的，然后通过start!然后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)))