{:group-id "puppetlabs", :artifact-id "jruby-utils", :version "4.1.1", :analysis {"clj" ({:name puppetlabs.services.jruby-pool-manager.impl.instance-pool, :publics ()} {:name puppetlabs.services.jruby-pool-manager.impl.jruby-agents, :publics ({:name add-instance, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_agents.clj", :line 47, :arglists ([{:keys [config], :as pool-context} id]), :doc "Inputs: [{:keys [config], :as pool-context} :- jruby-schemas/PoolContext id :- schema/Int]\n", :type :var} {:name borrow-all-jrubies, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_agents.clj", :line 119, :arglists ([pool-context]), :doc "Inputs: [pool-context :- jruby-schemas/PoolContext]\nReturns: [JRubyInstance]\n\nLocks the pool and borrows all the instances", :type :var} {:name borrow-all-jrubies*, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_agents.clj", :line 95, :arglists ([pool-context borrow-exception]), :doc "Inputs: [pool-context :- jruby-schemas/PoolContext borrow-exception :- IDeref]\n\nThe core logic for borrow-all-jrubies. Should only be called from borrow-all-jrubies", :type :var} {:name cleanup-and-refill-pool, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_agents.clj", :line 143, :arglists ([pool-context old-instances refill?]), :doc "Inputs: [pool-context :- jruby-schemas/PoolContext old-instances :- [JRubyInstance] refill? :- schema/Bool]\n\nCleans up the given instances and optionally refills the pool with\nnew instances. Should only be called from the modify-instance-agent", :type :var} {:name drain-and-refill-pool!, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_agents.clj", :line 172, :arglists ([pool-context refill?] [pool-context refill? on-complete]), :doc "Inputs: ([pool-context :- jruby-schemas/PoolContext refill? :- schema/Bool] [pool-context :- jruby-schemas/PoolContext refill? :- schema/Bool on-complete :- IDeref])\n\nBorrow and destroy all the jruby instances, optionally refilling the\npool with fresh jrubies. Locks the pool in order to drain it, but releases\nthe lock before destroying the instances and refilling the pool\n\nIf an on-complete promise is given, it can be used by the caller to make\nthis function syncronous. Otherwise it only blocks until the pool instances\nhave been borrowed and the cleanup-and-refill-pool fn is sent to the agent", :type :var} {:name flush-and-repopulate-pool!, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_agents.clj", :line 217, :arglists ([pool-context]), :doc "Inputs: [pool-context :- jruby-schemas/PoolContext]\n\nFlush of the current JRuby pool. Blocks until all the instances have\nbeen borrowed from the pool, but does not wait for the instances\nto be flushed or recreated", :type :var} {:name flush-instance!, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_agents.clj", :line 81, :arglists ([pool-context instance new-id config]), :doc "Inputs: [pool-context :- jruby-schemas/PoolContext instance :- JRubyInstance new-id :- schema/Int config :- jruby-schemas/JRubyConfig]\n\nFlush a single JRubyInstance.  Create a new replacement instance\nand insert it into the specified pool. Should only be called from\nthe modify-instance-agent", :type :var} {:name flush-pool-for-shutdown!, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_agents.clj", :line 199, :arglists ([pool-context]), :doc "Inputs: [pool-context :- jruby-schemas/PoolContext]\n\nFlush of the current JRuby pool when shutting down during a stop.", :type :var} {:name get-modify-instance-agent, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_agents.clj", :line 29, :arglists ([pool-context]), :doc "Inputs: [pool-context :- jruby-schemas/PoolContext]\nReturns: jruby-schemas/JRubyPoolAgent", :type :var} {:name get-shutdown-on-error-fn, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_agents.clj", :line 25, :arglists ([pool-context]), :doc "Inputs: [pool-context :- jruby-schemas/PoolContext]\nReturns: IFn", :type :var} {:name next-instance-id, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_agents.clj", :line 15, :arglists ([id pool-context]), :doc "Inputs: [id :- schema/Int pool-context :- jruby-schemas/PoolContext]\nReturns: schema/Int", :type :var} {:name pool-agent, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_agents.clj", :line 246, :arglists ([shutdown-on-error-fn]), :doc "Inputs: [shutdown-on-error-fn :- (schema/pred ifn?)]\nReturns: jruby-schemas/JRubyPoolAgent\n\nGiven a shutdown-on-error function, create an agent suitable for use in managing\nJRuby pools.", :type :var} {:name prime-pool!, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_agents.clj", :line 61, :arglists ([{:keys [config], :as pool-context}]), :doc "Inputs: [{:keys [config], :as pool-context} :- jruby-schemas/PoolContext]\n\nSequentially fill the pool with new JRubyInstances.  NOTE: this\nfunction should never be called except by the modify-instance-agent\nto create a pool's initial jruby instances.", :type :var} {:name send-agent, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_agents.clj", :line 33, :arglists ([jruby-agent f]), :doc "Inputs: [jruby-agent :- jruby-schemas/JRubyPoolAgent f :- IFn]\nReturns: jruby-schemas/JRubyPoolAgent\n\nUtility function; given a JRubyPoolAgent, send the specified function.\nEnsures that the function call is wrapped in a `shutdown-on-error`.", :type :var} {:name send-flush-instance!, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_agents.clj", :line 231, :arglists ([pool-context instance]), :doc "Inputs: [pool-context :- jruby-schemas/PoolContext instance :- JRubyInstance]\nReturns: jruby-schemas/JRubyPoolAgent\n\nSends requests to the flush-instance agent to flush the instance and create a new one.", :type :var})} {:name puppetlabs.services.jruby-pool-manager.impl.jruby-events, :publics ({:name create-borrowed-event, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_events.clj", :line 14, :arglists ([requested-event instance worker-id]), :doc "Inputs: [requested-event :- jruby-schemas/JRubyRequestedEvent instance :- jruby-schemas/JRubyBorrowResult worker-id :- jruby-schemas/JRubyWorkerId]\nReturns: jruby-schemas/JRubyBorrowedEvent", :type :var} {:name create-lock-acquired-event, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_events.clj", :line 38, :arglists ([reason]), :doc "Inputs: [reason :- jruby-schemas/JRubyEventReason]\nReturns: jruby-schemas/JRubyLockAcquiredEvent", :type :var} {:name create-lock-released-event, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_events.clj", :line 43, :arglists ([reason]), :doc "Inputs: [reason :- jruby-schemas/JRubyEventReason]\nReturns: jruby-schemas/JRubyLockReleasedEvent", :type :var} {:name create-lock-requested-event, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_events.clj", :line 33, :arglists ([reason]), :doc "Inputs: [reason :- jruby-schemas/JRubyEventReason]\nReturns: jruby-schemas/JRubyLockRequestedEvent", :type :var} {:name create-requested-event, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_events.clj", :line 9, :arglists ([reason]), :doc "Inputs: [reason :- jruby-schemas/JRubyEventReason]\nReturns: jruby-schemas/JRubyRequestedEvent", :type :var} {:name create-returned-event, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_events.clj", :line 24, :arglists ([instance reason worker-id]), :doc "Inputs: [instance :- jruby-schemas/JRubyInstanceOrPill reason :- jruby-schemas/JRubyEventReason worker-id :- jruby-schemas/JRubyWorkerId]\nReturns: jruby-schemas/JRubyReturnedEvent", :type :var} {:name instance-borrowed, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_events.clj", :line 63, :arglists ([event-callbacks requested-event instance worker-id]), :doc "Inputs: [event-callbacks :- [IFn] requested-event :- jruby-schemas/JRubyRequestedEvent instance :- jruby-schemas/JRubyBorrowResult worker-id :- jruby-schemas/JRubyWorkerId]\nReturns: jruby-schemas/JRubyBorrowedEvent", :type :var} {:name instance-requested, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_events.clj", :line 58, :arglists ([event-callbacks reason]), :doc "Inputs: [event-callbacks :- [IFn] reason :- jruby-schemas/JRubyEventReason]\nReturns: jruby-schemas/JRubyRequestedEvent", :type :var} {:name instance-returned, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_events.clj", :line 70, :arglists ([event-callbacks instance reason worker-id]), :doc "Inputs: [event-callbacks :- [IFn] instance :- jruby-schemas/JRubyInstanceOrPill reason :- jruby-schemas/JRubyEventReason worker-id :- jruby-schemas/JRubyWorkerId]\nReturns: jruby-schemas/JRubyReturnedEvent", :type :var} {:name lock-acquired, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_events.clj", :line 82, :arglists ([event-callbacks reason]), :doc "Inputs: [event-callbacks :- [IFn] reason :- jruby-schemas/JRubyEventReason]\nReturns: jruby-schemas/JRubyLockAcquiredEvent", :type :var} {:name lock-released, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_events.clj", :line 87, :arglists ([event-callbacks reason]), :doc "Inputs: [event-callbacks :- [IFn] reason :- jruby-schemas/JRubyEventReason]\nReturns: jruby-schemas/JRubyLockReleasedEvent", :type :var} {:name lock-requested, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_events.clj", :line 77, :arglists ([event-callbacks reason]), :doc "Inputs: [event-callbacks :- [IFn] reason :- jruby-schemas/JRubyEventReason]\nReturns: jruby-schemas/JRubyLockRequestedEvent", :type :var} {:name notify-event-listeners, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_events.clj", :line 48, :arglists ([event-callbacks event]), :doc "Inputs: [event-callbacks :- [IFn] event :- jruby-schemas/JRubyEvent]\nReturns: jruby-schemas/JRubyEvent", :type :var})} {:name puppetlabs.services.jruby-pool-manager.impl.jruby-internal, :publics ({:name borrow-from-pool, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_internal.clj", :line 329, :arglists ([pool-context]), :doc "Inputs: [pool-context :- jruby-schemas/PoolContext]\nReturns: jruby-schemas/JRubyInstanceOrPill\n\nBorrows a JRuby interpreter from the pool. If there are no instances\nleft in the pool then this function will block until there is one available.", :type :var} {:name borrow-from-pool!*, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_internal.clj", :line 300, :arglists ([borrow-fn pool]), :doc "Inputs: [borrow-fn :- (schema/pred ifn?) pool :- jruby-schemas/pool-queue-type]\nReturns: jruby-schemas/JRubyBorrowResult\n\nGiven a borrow function and a pool, attempts to borrow a JRubyInstance from a pool.\nIf successful, updates the state information and returns the JRubyInstance.\nReturns nil if the borrow function returns nil; throws an exception if\nthe borrow function's return value indicates an error condition.", :type :var} {:name borrow-from-pool-with-timeout, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_internal.clj", :line 337, :arglists ([pool-context timeout]), :doc "Inputs: [pool-context :- jruby-schemas/PoolContext timeout :- schema/Int]\nReturns: jruby-schemas/JRubyBorrowResult\n\nBorrows a JRuby interpreter from the pool, like borrow-from-pool but a\nblocking timeout is provided. If an instance is available then it will be\nimmediately returned to the caller, if not then this function will block\nwaiting for an instance to be free for the number of milliseconds given in\ntimeout. If the timeout runs out then nil will be returned, indicating that\nthere were no instances available.", :type :var} {:name borrow-with-timeout-fn, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_internal.clj", :line 130, :arglists ([timeout pool]), :doc "Inputs: [timeout :- schema/Int pool :- jruby-schemas/pool-queue-type]\nReturns: jruby-schemas/JRubyInternalBorrowResult", :type :var} {:name borrow-without-timeout-fn, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_internal.clj", :line 296, :arglists ([pool]), :doc "Inputs: [pool :- jruby-schemas/pool-queue-type]\nReturns: jruby-schemas/JRubyInternalBorrowResult", :type :var} {:name cleanup-pool-instance!, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_internal.clj", :line 193, :arglists ([{:keys [scripting-container], :as instance} cleanup-fn]), :doc "Inputs: [{:keys [scripting-container], :as instance} :- JRubyInstance cleanup-fn :- IFn]\n\nCleans up and cleanly terminates a JRubyInstance and removes it from the pool.", :type :var} {:name create-pool-from-config, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_internal.clj", :line 181, :arglists ([config]), :doc "Inputs: [config :- jruby-schemas/JRubyConfig]\nReturns: jruby-schemas/PoolState\n\nCreate a new PoolState based on the config input.", :type :var} {:name create-pool-instance!, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_internal.clj", :line 225, :arglists ([pool id config] [pool id config initial-jruby?]), :doc "Inputs: ([pool :- jruby-schemas/pool-queue-type id :- schema/Int config :- jruby-schemas/JRubyConfig] [pool :- jruby-schemas/pool-queue-type id :- schema/Int config :- jruby-schemas/JRubyConfig initial-jruby? :- schema/Bool])\nReturns: JRubyInstance\n\nCreates a new JRubyInstance and adds it to the pool.", :type :var} {:name create-scripting-container, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_internal.clj", :line 113, :arglists ([config]), :doc "Inputs: [config :- jruby-schemas/JRubyConfig]\nReturns: ScriptingContainer\n\nCreates an instance of `org.jruby.embed.ScriptingContainer`.", :type :var} {:name empty-scripting-container, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_internal.clj", :line 107, :arglists ([config]), :doc "Inputs: [config :- jruby-schemas/JRubyConfig]\nReturns: ScriptingContainer\n\nCreates a clean instance of a JRuby `ScriptingContainer` with no code loaded.", :type :var} {:name get-compile-mode, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_internal.clj", :line 47, :arglists ([config-compile-mode]), :doc "Inputs: [config-compile-mode :- jruby-schemas/SupportedJRubyCompileModes]\nReturns: RubyInstanceConfig$CompileMode", :type :var} {:name get-flush-timeout, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_internal.clj", :line 284, :arglists ([context]), :doc "Inputs: [context :- jruby-schemas/PoolContext]\nReturns: schema/Int\n\nGets the size of the JRuby pool from the pool context.", :type :var} {:name get-instance-state-container, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_internal.clj", :line 290, :arglists ([instance]), :doc "Inputs: [instance :- JRubyInstance]\nReturns: jruby-schemas/JRubyInstanceStateContainer\n\nGets the InstanceStateContainer (atom) from the instance.", :type :var} {:name get-instance-thread-dump, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_internal.clj", :line 357, :arglists ([instance]), :doc "Inputs: [instance :- JRubyInstance]\n", :type :var} {:name get-jruby-runtime, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_internal.clj", :line 144, :arglists ([{:keys [scripting-container]}]), :doc "Inputs: [{:keys [scripting-container]} :- JRubyInstance]\nReturns: Ruby\n\nGet the org.jruby.Ruby instance associated with member of the pool.", :type :var} {:name get-pool, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_internal.clj", :line 272, :arglists ([context]), :doc "Inputs: [context :- jruby-schemas/PoolContext]\nReturns: jruby-schemas/pool-queue-type\n\nGets the JRuby pool object from the pool context.", :type :var} {:name get-pool-size, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_internal.clj", :line 278, :arglists ([context]), :doc "Inputs: [context :- jruby-schemas/PoolContext]\nReturns: schema/Int\n\nGets the size of the JRuby pool from the pool context.", :type :var} {:name get-pool-state, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_internal.clj", :line 266, :arglists ([context]), :doc "Inputs: [context :- jruby-schemas/PoolContext]\nReturns: jruby-schemas/PoolState\n\nGets the PoolState from the pool context.", :type :var} {:name get-pool-state-container, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_internal.clj", :line 260, :arglists ([context]), :doc "Inputs: [context :- jruby-schemas/PoolContext]\nReturns: jruby-schemas/PoolStateContainer\n\nGets the PoolStateContainer from the pool context.", :type :var} {:name get-profiling-mode, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_internal.clj", :line 54, :arglists ([config-profiling-mode]), :doc "Inputs: [config-profiling-mode :- jruby-schemas/SupportedJRubyProfilingModes]\nReturns: RubyInstanceConfig$ProfilingMode", :type :var} {:name init-jruby, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_internal.clj", :line 92, :arglists ([jruby config]), :doc "Inputs: [jruby :- jruby-schemas/ConfigurableJRuby config :- jruby-schemas/JRubyConfig]\nReturns: jruby-schemas/ConfigurableJRuby\n\nApplies configuration to a JRuby... thing.  See comments in `ConfigurableJRuby`\nschema for more details.", :type :var} {:name initial-borrows-value, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_internal.clj", :line 205, :arglists ([id total-instances total-borrows initial-jruby?]), :doc "Inputs: [id :- schema/Int total-instances :- schema/Int total-borrows :- schema/Int initial-jruby? :- schema/Bool]\nReturns: (schema/maybe schema/Int)\n\nDetermines how many borrows before instance of given id should be flushed\nin order to best splay it. Returns nil if not applicable (either not\n`initial-jruby?` or there are more instances than max-borrows).", :type :var} {:name initialize-gem-path, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_internal.clj", :line 29, :arglists ([{:keys [gem-path gem-home], :as jruby-config}]), :doc "Inputs: [{:keys [gem-path gem-home], :as jruby-config} :- #:schema{Keyword schema/Any}]\nReturns: #:schema{Keyword schema/Any}", :type :var} {:name insert-poison-pill, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_internal.clj", :line 139, :arglists ([pool error]), :doc "Inputs: [pool :- jruby-schemas/pool-queue-type error :- Throwable]\n", :type :var} {:name insert-shutdown-poison-pill, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_internal.clj", :line 135, :arglists ([pool]), :doc "Inputs: [pool :- jruby-schemas/pool-queue-type]\n", :type :var} {:name instantiate-instance-pool, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_internal.clj", :line 35, :arglists ([size]), :doc "Instantiate a new queue object to use as the pool of free JRuby's.\n", :type :var} {:name instantiate-reference-pool, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_internal.clj", :line 41, :arglists ([max-concurrent-borrows]), :doc "Instantiate a new queue object to use as the pool of free JRuby's.\n", :type :var} {:name jmx-bean-name, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_internal.clj", :line 168, :arglists ([instance service-name]), :doc "Inputs: [instance :- JRubyInstance service-name :- JRubyMBeanName]\nReturns: schema/Str\n\nGet the fully-qualified name of a JMX MBean attached to a JRubyInstance.", :type :var} {:name JRubyMBeanName, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_internal.clj", :line 159, :doc "Enumeration of available JMX MBeans for a JRubyInstance.\n", :type :var} {:name management-enabled?, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_internal.clj", :line 152, :arglists ([instance]), :doc "Inputs: [instance :- JRubyInstance]\nReturns: schema/Bool", :type :var} {:name new-main, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_internal.clj", :line 371, :arglists ([config]), :doc "Inputs: [config :- jruby-schemas/JRubyConfig]\nReturns: jruby-schemas/JRubyMain\n\nReturn a new JRubyMain instance which should only be used for CLI purposes,\ne.g. for the ruby, gem, and irb subcommands.  Internal core services should\nuse `create-scripting-container` instead of `new-main`.", :type :var} {:name set-config-encoding, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_internal.clj", :line 74, :arglists ([kcode jruby]), :doc "Inputs: [kcode :- KCode jruby :- RubyInstanceConfig]\nReturns: RubyInstanceConfig\n\nSets the K code, source encoding, and external encoding of the JRuby config to\nthe supplied encoding.", :type :var} {:name set-ruby-encoding, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_internal.clj", :line 85, :arglists ([kcode jruby]), :doc "Inputs: [kcode :- KCode jruby :- jruby-schemas/ConfigurableJRuby]\nReturns: jruby-schemas/ConfigurableJRuby", :type :var} {:name setup-profiling, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_internal.clj", :line 58, :arglists ([jruby profiler-output-file profiling-mode]), :doc "Inputs: [jruby :- jruby-schemas/ConfigurableJRuby profiler-output-file :- schema/Str profiling-mode :- schema/Keyword]\n\nTakes a jruby and sets profiling mode and profiler output, appending the\ncurrent time to the filename for uniqueness and notifying the user via log\nmessage of the profile file name.", :type :var} {:name throw-jruby-lock-timeout, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_internal.clj", :line 351, :arglists ([exception]), :type :var})} {:name puppetlabs.services.jruby-pool-manager.impl.jruby-pool-manager-core, :publics ({:name create-pool, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_pool_manager_core.clj", :line 24, :arglists ([config]), :doc "Inputs: [config :- jruby-schemas/JRubyConfig]\nReturns: jruby-schemas/PoolContext", :type :var} {:name create-pool-context, :file "puppetlabs/services/jruby_pool_manager/impl/jruby_pool_manager_core.clj", :line 11, :arglists ([config]), :doc "Inputs: [config :- jruby-schemas/JRubyConfig]\nReturns: jruby-schemas/PoolContext\n\nCreates a new JRuby pool context with an empty pool. Once the JRuby\npool object has been created, it will need to be filled using `prime-pool!`.", :type :var})} {:name puppetlabs.services.jruby-pool-manager.impl.reference-pool, :publics ({:name flush-if-at-max-borrows, :file "puppetlabs/services/jruby_pool_manager/impl/reference_pool.clj", :line 41, :arglists ([pool-context instance]), :doc "Inputs: [pool-context :- jruby-schemas/PoolContext instance :- JRubyInstance]\n", :type :var} {:name flush-pool*, :file "puppetlabs/services/jruby_pool_manager/impl/reference_pool.clj", :line 16, :arglists ([pool-context]), :doc "Inputs: [pool-context :- jruby-schemas/PoolContext]\n\nFlushes the pool, assuming it has already been locked by the calling function.\nDo not call this without first locking the pool, or the flush may never complete,\nsince it requires that all references be returned to proceed.", :type :var} {:name max-borrows-exceeded, :file "puppetlabs/services/jruby_pool_manager/impl/reference_pool.clj", :line 33, :arglists ([current-borrows max-borrows]), :doc "Inputs: [current-borrows :- schema/Int max-borrows :- schema/Int]\nReturns: schema/Bool\n\nReturns true if max-borrows is set and the current borrow count has\nexceeded the allowed maximum.", :type :var})} {:name puppetlabs.services.jruby-pool-manager.jruby-core, :publics ({:name add-gem-path, :file "puppetlabs/services/jruby_pool_manager/jruby_core.clj", :line 94, :arglists ([env config]), :doc "Inputs: [env :- #:schema{Str schema/Str} config :- jruby-schemas/JRubyConfig]\n", :type :var} {:name borrow-from-pool, :file "puppetlabs/services/jruby_pool_manager/jruby_core.clj", :line 195, :arglists ([pool-context reason event-callbacks]), :doc "Inputs: [pool-context :- jruby-schemas/PoolContext reason :- schema/Any event-callbacks :- [IFn]]\nReturns: jruby-schemas/JRubyInstanceOrPill\n\nBorrows a JRuby interpreter from the pool. If there are no instances\nleft in the pool then this function will block until there is one available.", :type :var} {:name borrow-from-pool-with-timeout, :file "puppetlabs/services/jruby_pool_manager/jruby_core.clj", :line 209, :arglists ([pool-context reason event-callbacks]), :doc "Inputs: [pool-context :- jruby-schemas/PoolContext reason :- schema/Any event-callbacks :- [IFn]]\nReturns: jruby-schemas/JRubyBorrowResult\n\nBorrows a JRuby interpreter from the pool, like borrow-from-pool but a\nblocking timeout is taken from the config in the context. If an instance is\navailable then it will be immediately returned to the caller, if not then\nthis function will block waiting for an instance to be free for the number\nof milliseconds given in timeout. If the timeout runs out then nil will be\nreturned, indicating that there were no instances available.", :type :var} {:name cli-ruby!, :file "puppetlabs/services/jruby_pool_manager/jruby_core.clj", :line 289, :arglists ([config args]), :doc "Inputs: [config :- jruby-schemas/JRubyConfig args :- [schema/Str]]\nReturns: jruby-schemas/JRubyMainStatus\n\nRun JRuby as though native `ruby` were invoked with args on the CLI", :type :var} {:name cli-run!, :file "puppetlabs/services/jruby_pool_manager/jruby_core.clj", :line 297, :arglists ([config command args]), :doc "Inputs: [config :- jruby-schemas/JRubyConfig command :- schema/Str args :- [schema/Str]]\nReturns: (schema/maybe jruby-schemas/JRubyMainStatus)\n\nRun a JRuby CLI command, e.g. gem, irb, etc...", :type :var} {:name default-borrow-timeout, :file "puppetlabs/services/jruby_pool_manager/jruby_core.clj", :line 30, :doc "Default timeout when borrowing instances from the JRuby pool in\nmilliseconds. Current value is 1200000ms, or 20 minutes.", :type :var} {:name default-flush-timeout, :file "puppetlabs/services/jruby_pool_manager/jruby_core.clj", :line 35, :doc "Default timeout when flushing the JRuby pool in milliseconds.\nCurrent value is 1200000ms, or 20 minutes.", :type :var} {:name default-initialize-scripting-container, :file "puppetlabs/services/jruby_pool_manager/jruby_core.clj", :line 139, :arglists ([scripting-container config]), :doc "Inputs: [scripting-container :- jruby-schemas/ConfigurableJRuby config :- jruby-schemas/JRubyConfig]\nReturns: jruby-schemas/ConfigurableJRuby\n\nDefault lifecycle fn for initializing the settings on the scripting\ncontainer. Currently it just sets the environment variables.", :type :var} {:name default-jruby-compile-mode, :file "puppetlabs/services/jruby_pool_manager/jruby_core.clj", :line 25, :doc "Default for JRuby's CompileMode setting. Defaults to JIT for Jruby\n9k.", :type :var} {:name default-pool-size, :file "puppetlabs/services/jruby_pool_manager/jruby_core.clj", :line 43, :arglists ([num-cpus]), :doc "Calculate the default size of the JRuby pool, based on the number of cpus.\n", :type :var} {:name env-vars-allowed-list, :file "puppetlabs/services/jruby_pool_manager/jruby_core.clj", :line 105, :doc "A list of environment variables that are allowed to be passed through from the environment.\n", :type :var} {:name flush-pool!, :file "puppetlabs/services/jruby_pool_manager/jruby_core.clj", :line 239, :arglists ([pool-context]), :doc "Inputs: [pool-context]\n\nFlush all the current JRubyInstances and repopulate the pool.", :type :var} {:name flush-pool-for-shutdown!, :file "puppetlabs/services/jruby_pool_manager/jruby_core.clj", :line 245, :arglists ([pool-context]), :doc "Inputs: [pool-context]\n\nFlush all the current JRubyInstances so that the pool can be shutdown\nwithout any instances being active.", :type :var} {:name free-instance-count, :file "puppetlabs/services/jruby_pool_manager/jruby_core.clj", :line 71, :arglists ([pool]), :doc "Inputs: [pool :- jruby-schemas/pool-queue-type]\n\nReturns the number of JRubyInstances available in the pool.", :type :var} {:name get-event-callbacks, :file "puppetlabs/services/jruby_pool_manager/jruby_core.clj", :line 83, :arglists ([pool-context]), :doc "Inputs: [pool-context :- jruby-schemas/PoolContext]\nReturns: [IFn]\n\nGets the vector of event callbacks from the pool context.", :type :var} {:name get-instance-state, :file "puppetlabs/services/jruby_pool_manager/jruby_core.clj", :line 77, :arglists ([jruby-instance]), :doc "Inputs: [jruby-instance :- JRubyInstance]\nReturns: jruby-schemas/JRubyInstanceState\n\nGet the state metadata for a JRubyInstance.", :type :var} {:name get-jruby-thread-dump, :file "puppetlabs/services/jruby_pool_manager/jruby_core.clj", :line 185, :arglists ([pool-context]), :doc "Inputs: [pool-context :- jruby-schemas/PoolContext]\n\nGet thread dumps from JRuby instances in the pool.", :type :var} {:name get-pool, :file "puppetlabs/services/jruby_pool_manager/jruby_core.clj", :line 56, :arglists ([context]), :doc "Inputs: [context :- jruby-schemas/PoolContext]\nReturns: jruby-schemas/pool-queue-type\n\nGets the JRuby pool object from the pool context.", :type :var} {:name get-pool-state, :file "puppetlabs/services/jruby_pool_manager/jruby_core.clj", :line 50, :arglists ([context]), :doc "Inputs: [context :- jruby-schemas/PoolContext]\nReturns: jruby-schemas/PoolState\n\nGets the PoolState from the pool context.", :type :var} {:name get-system-env, :file "puppetlabs/services/jruby_pool_manager/jruby_core.clj", :line 88, :arglists ([]), :doc "Inputs: []\nReturns: jruby-schemas/EnvPersistentMap\n\nSame as System/getenv, but returns a clojure persistent map instead of a\nJava unmodifiable map.", :type :var} {:name initialize-config, :file "puppetlabs/services/jruby_pool_manager/jruby_core.clj", :line 160, :arglists ([config]), :doc "Inputs: [config :- #:schema{Keyword schema/Any}]\nReturns: jruby-schemas/JRubyConfig\n\nInitialize keys with default settings if they are not given a value.\nThe config is validated after these defaults are set.", :type :var} {:name initialize-lifecycle-fns, :file "puppetlabs/services/jruby_pool_manager/jruby_core.clj", :line 147, :arglists ([config]), :doc "Inputs: [config :- (schema/maybe {(schema/optional-key :initialize-pool-instance) IFn, (schema/optional-key :cleanup) IFn, (schema/optional-key :shutdown-on-error) IFn, (schema/optional-key :initialize-scripting-container) IFn})]\nReturns: jruby-schemas/LifecycleFns", :type :var} {:name jruby-version-info, :file "puppetlabs/services/jruby_pool_manager/jruby_core.clj", :line 366, :doc "Default version info string for jruby\n", :type :var} {:name lock-pool, :file "puppetlabs/services/jruby_pool_manager/jruby_core.clj", :line 252, :arglists ([pool-context reason event-callbacks]), :doc "Inputs: [pool-context :- jruby-schemas/PoolContext reason :- schema/Any event-callbacks :- [IFn]]\n\nLocks the JRuby pool for exclusive access.", :type :var} {:name lock-pool-with-timeout, :file "puppetlabs/services/jruby_pool_manager/jruby_core.clj", :line 264, :arglists ([pool-context timeout-ms reason event-callbacks]), :doc "Inputs: [pool-context :- jruby-schemas/PoolContext timeout-ms :- schema/Int reason :- schema/Any event-callbacks :- [IFn]]\n\nLocks the JRuby pool for exclusive access using a timeout in milliseconds.\nIf the timeout is exceeded, a TimeoutException will be thrown and\nthe pool will remain unlocked", :type :var} {:name managed-environment, :file "puppetlabs/services/jruby_pool_manager/jruby_core.clj", :line 109, :arglists ([env config]), :doc "Inputs: [env :- jruby-schemas/EnvMap config :- jruby-schemas/JRubyConfig]\nReturns: jruby-schemas/EnvMap\n\nThe environment variables that should be passed to the JRuby interpreters.\n\nWe don't want them to read any ruby environment variables, like $RUBY_LIB or\nanything like that, so pass it an empty environment map - except - most things\nneeds HOME and PATH to work, so leave those, along with GEM_HOME and GEM_PATH,\nwhich are necessary for extensions that depend on gems.\n\nWe need to set the JARS..REQUIRE variables in order to instruct JRuby's\n'jar-dependencies' to not try to load any dependent jars.  This is being\ndone specifically to avoid JRuby trying to load its own version of Bouncy\nCastle, which may not the same as the one that 'puppetlabs/ssl-utils'\nuses. JARS_NO_REQUIRE was the legacy way to turn off jar loading but is\nbeing phased out in favor of JARS_REQUIRE.  As of JRuby 1.7.20, only\nJARS_NO_REQUIRE is honored.  Setting both of those here for forward\ncompatibility.\n\nWe also merge an environment-vars map with the config to allow for configured\nenvironment variables to be visible to the Ruby code. This map is by default\nset to {} if the user does not specify it in the configuration file.", :type :var} {:name proxy-vars-allowed-list, :file "puppetlabs/services/jruby_pool_manager/jruby_core.clj", :line 101, :doc "A list of proxy-related variables that are allowed to be passed the environment\n", :type :var} {:name register-event-handler, :file "puppetlabs/services/jruby_pool_manager/jruby_core.clj", :line 179, :arglists ([pool-context callback-fn]), :doc "Inputs: [pool-context :- jruby-schemas/PoolContext callback-fn :- IFn]\n\nRegister the callback function by adding it to the event callbacks atom on the pool context.", :type :var} {:name registered-instances, :file "puppetlabs/services/jruby_pool_manager/jruby_core.clj", :line 62, :arglists ([context]), :doc "Inputs: [context :- jruby-schemas/PoolContext]\nReturns: [JRubyInstance]", :type :var} {:name return-to-pool, :file "puppetlabs/services/jruby_pool_manager/jruby_core.clj", :line 228, :arglists ([pool-context instance reason event-callbacks]), :doc "Inputs: [pool-context :- jruby-schemas/PoolContext instance :- jruby-schemas/JRubyInstanceOrPill reason :- schema/Any event-callbacks :- [IFn]]\n\nReturn a borrowed pool instance to its free pool.", :type :var} {:name unlock-pool, :file "puppetlabs/services/jruby_pool_manager/jruby_core.clj", :line 279, :arglists ([pool-context reason event-callbacks]), :doc "Inputs: [pool-context :- jruby-schemas/PoolContext reason :- schema/Any event-callbacks :- [IFn]]\n\nUnlocks the JRuby pool, restoring concurernt access.", :type :var} {:name with-jruby-instance, :file "puppetlabs/services/jruby_pool_manager/jruby_core.clj", :line 311, :arglists ([jruby-instance pool-context reason & body]), :doc "Encapsulates the behavior of borrowing and returning a JRubyInstance.\nExample usage:\n\n(let [pool-manager-service (tk-app/get-service app :PoolManagerService)\n      pool-context (pool-manager/create-pool pool-manager-service config)]\n  (with-jruby-instance\n    jruby-instance\n    pool-context\n    reason\n\n    (do-something-with-a-jruby-instance jruby-instance)))\n\nWill throw an IllegalStateException if borrowing a JRubyInstance times out.", :type :macro} {:name with-lock, :file "puppetlabs/services/jruby_pool_manager/jruby_core.clj", :line 344, :arglists ([pool-context reason & body]), :doc "Acquires a lock on the pool, executes the body, and releases the lock.\n", :type :macro} {:name with-lock-with-timeout, :file "puppetlabs/services/jruby_pool_manager/jruby_core.clj", :line 354, :arglists ([pool-context timeout-ms reason & body]), :doc "Acquires a lock on the pool with a timeout in milliseconds,\nexecutes the body, and releases the lock. If the timeout is exceeded,\na TimeoutException will be thrown", :type :macro})} {:name puppetlabs.services.jruby-pool-manager.jruby-pool-manager-service, :publics ({:name jruby-pool-manager-service, :file "puppetlabs/services/jruby_pool_manager/jruby_pool_manager_service.clj", :line 8, :type :var})} {:name puppetlabs.services.jruby-pool-manager.jruby-schemas, :publics ({:name ConfigurableJRuby, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 211, :type :var} {:name EnvMap, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 224, :doc "System Environment variables have strings for the keys and values of a map\n", :type :var} {:name EnvPersistentMap, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 228, :doc "Schema for a clojure persistent map for the system environment\n", :type :var} {:name event-type-borrowed?, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 237, :arglists ([e]), :type :var} {:name event-type-lock-acquired?, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 249, :arglists ([e]), :type :var} {:name event-type-lock-released?, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 253, :arglists ([e]), :type :var} {:name event-type-lock-requested?, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 245, :arglists ([e]), :type :var} {:name event-type-requested?, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 233, :arglists ([e]), :type :var} {:name event-type-returned?, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 241, :arglists ([e]), :type :var} {:name jruby-instance-config?, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 169, :arglists ([x]), :type :var} {:name jruby-instance?, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 153, :arglists ([x]), :type :var} {:name jruby-main-instance?, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 157, :arglists ([x]), :type :var} {:name jruby-main-status-instance?, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 161, :arglists ([x]), :type :var} {:name jruby-scripting-container?, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 165, :arglists ([x]), :type :var} {:name JRubyBorrowedEvent, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 264, :type :var} {:name JRubyBorrowResult, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 193, :type :var} {:name JRubyConfig, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 47, :doc "Schema defining the config map for the JRuby pooling functions.\n\nThe keys should have the following values:\n\n  * :ruby-load-path - a vector of file paths, containing the locations of ruby source code.\n\n  * :gem-home - The location that JRuby gems will be installed\n\n  * :gem-path - The full path where JRuby should look for gems\n\n  * :compile-mode - The value to use for JRuby's CompileMode setting.  Legal\n      values are `:jit`, `:force`, and `:off`.  Defaults to `:off`.\n\n  * :max-active-instances - The maximum number of JRubyInstances that\n      will be pooled.\n\n  * :splay-instance-flush - Whether or not to splay flushing of instances\n\n  * :environment-vars - A map of environment variables and their values to be\n      passed through to the JRuby scripting container and visible to any Ruby code.\n\n  * :profiling-mode - The value to use for JRuby's ProfilerMode setting. Legal\n      values are `:api`, `:flat`, `:graph`, `:html`, `:json`, `:off`, and\n      `:service`. Defaults to `:off`.\n\n  * :profiler-output-file - A target file to direct profiler output to. If\n      not set, defaults to a random file relative to the working directory\n      of the service.", :type :var} {:name JRubyEvent, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 289, :type :var} {:name JRubyEventReason, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 257, :type :var} {:name JRubyInstanceOrPill, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 181, :type :var} {:name JRubyInstanceState, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 131, :doc "State metadata for an individual JRubyInstance\n", :type :var} {:name JRubyInstanceStateContainer, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 135, :doc "An atom containing the current state of a given JRubyInstance.\n", :type :var} {:name JRubyInternalBorrowResult, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 186, :type :var} {:name JRubyLockAcquiredEvent, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 281, :type :var} {:name JRubyLockReleasedEvent, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 285, :type :var} {:name JRubyLockRequestedEvent, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 277, :type :var} {:name JRubyMain, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 205, :type :var} {:name JRubyMainStatus, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 208, :type :var} {:name JRubyPoolAgent, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 91, :doc "An agent configured for use in managing JRuby pools\n", :type :var} {:name JRubyPuppetInstanceInternal, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 141, :type :var} {:name JRubyRequestedEvent, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 260, :type :var} {:name JRubyReturnedEvent, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 271, :type :var} {:name JRubyWorkerId, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 201, :type :var} {:name LifecycleFns, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 41, :type :var} {:name map->InstancePool, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 123, :arglists ([m5211]), :doc "Factory function for class InstancePool, taking a map of keywords to field values, but not much\nslower than ->x like the clojure.core version.\n(performance is fixed in Clojure 1.7, so this should eventually be removed.)", :type :var} {:name map->JRubyInstance, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 147, :arglists ([m5272]), :doc "Factory function for class JRubyInstance, taking a map of keywords to field values, but not much\nslower than ->x like the clojure.core version.\n(performance is fixed in Clojure 1.7, so this should eventually be removed.)", :type :var} {:name map->ReferencePool, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 118, :arglists ([m5151]), :doc "Factory function for class ReferencePool, taking a map of keywords to field values, but not much\nslower than ->x like the clojure.core version.\n(performance is fixed in Clojure 1.7, so this should eventually be removed.)", :type :var} {:name poison-pill?, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 173, :arglists ([x]), :type :var} {:name pool-queue-type, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 12, :doc "The Java datastructure type used to store JRubyInstances which are\nfree to be borrowed.", :type :var} {:name PoolContext, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 127, :type :var} {:name PoolContextInternal, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 112, :doc "The data structure that stores all JRuby pools\n", :type :var} {:name PoolState, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 101, :doc "A map that describes all attributes of a particular JRuby pool.\n", :type :var} {:name PoolStateContainer, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 106, :doc "An atom containing the current state of all of the JRuby pool.\n", :type :var} {:name shutdown-poison-pill?, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 177, :arglists ([x]), :type :var} {:name strict-map->InstancePool, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 123, :arglists ([m5212 & [drop-extra-keys?__1884__auto__]]), :doc "Factory function for class InstancePool, taking a map of keywords to field values.  All keys are required, and no extra keys are allowed.  Even faster than map->\n", :type :var} {:name strict-map->JRubyInstance, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 147, :arglists ([m5273 & [drop-extra-keys?__1884__auto__]]), :doc "Factory function for class JRubyInstance, taking a map of keywords to field values.  All keys are required, and no extra keys are allowed.  Even faster than map->\n", :type :var} {:name strict-map->ReferencePool, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 118, :arglists ([m5152 & [drop-extra-keys?__1884__auto__]]), :doc "Factory function for class ReferencePool, taking a map of keywords to field values.  All keys are required, and no extra keys are allowed.  Even faster than map->\n", :type :var} {:name supported-jruby-compile-modes, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 30, :type :var} {:name SupportedJRubyCompileModes, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 33, :doc "Schema defining the supported values for the JRuby CompileMode setting.\n", :type :var} {:name SupportedJRubyProfilingModes, :file "puppetlabs/services/jruby_pool_manager/jruby_schemas.clj", :line 37, :doc "Schema defining the supported values for the JRuby ProfilingMode setting.\n", :type :var})} {:name puppetlabs.services.protocols.jruby-pool, :publics ({:name JRubyPool, :file "puppetlabs/services/protocols/jruby_pool.clj", :line 3, :type :protocol, :members ({:name borrow, :arglists ([pool-context]), :doc "Returns a reference to a JRuby instance and a worker id (instance id or thread id).\nWill block if the pool is locked or no instances are available.", :type :var} {:name borrow-with-timeout, :arglists ([pool-context timeout]), :doc "Returns a reference to a JRuby instance and a worker id (instance id or thread id).\nWill block if the pool is locked or no instances are available, timing out when the\nsupplied number of milliseconds has elapsed.", :type :var} {:name fill, :arglists ([pool-context]), :doc "Creates all the necessary JRuby instances and adds them to the pool.\n", :type :var} {:name flush-pool, :arglists ([pool-context]), :doc "Removes and terminates all the JRuby instances from the pool, then creates new ones and adds\nthem to the pool. Note that when using the ReferencePool, this will cause the pool to be locked,\nwith a timeout equal to the configured `flush-timeout`.", :type :var} {:name lock, :arglists ([pool-context]), :doc "Blocks waiting for all currently held JRubies to be returned to the pool, preventing further\nborrows until the pool is unlocked.", :type :var} {:name lock-with-timeout, :arglists ([pool-context timeout time-unit]), :doc "Attempts to lock the JRuby pool, timing out if the supplied interval has elapsed.\n", :type :var} {:name return, :arglists ([pool-context instance]), :doc "Releases a held reference to a JRuby instance back to the pool and returns the worker id\n(instance id or thread id) for the thing being returned. If `max-requests-per-instance`\nis configured and has been reached for this instance, this function will trigger a flush of\nthe instance. Note that when using the ReferencePool, this will also cause the pool to be locked.\n\nIf something besides a JRuby instance is passed to return (e.g. a Pill), this function is a no-op.", :type :var} {:name shutdown, :arglists ([pool-context]), :doc "Shuts down the JRuby pool, inserting a poison pill to prevent further borrows and terminating\nall JRuby instances.", :type :var} {:name unlock, :arglists ([pool-context]), :doc "Unlocks the JRuby pool, allowing borrows to proceed.\n", :type :var} {:name worker-id, :arglists ([pool-context instance]), :doc "Returns the worker id for given instance (instance id or thread id).\n", :type :var})})} {:name puppetlabs.services.protocols.pool-manager, :publics ({:name PoolManagerService, :file "puppetlabs/services/protocols/pool_manager.clj", :line 3, :type :protocol, :members ({:name create-pool, :arglists ([this config]), :doc "Create a pool and fill it with the number of JRubyInstances specified.\nReturn the pool context.", :type :var})})})}, :pom-str "<?xml version=\"1.0\" encoding=\"UTF-8\"?><project xmlns=\"http://maven.apache.org/POM/4.0.0\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation=\"http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd\">\n  <modelVersion>4.0.0</modelVersion>\n  <groupId>puppetlabs</groupId>\n  <artifactId>jruby-utils</artifactId>\n  <packaging>jar</packaging>\n  <version>4.1.1</version>\n  <name>jruby-utils</name>\n  <description>A library for working with JRuby</description>\n  <url>https://github.com/puppetlabs/jruby-utils</url>\n  <licenses>\n    <license>\n      <name>Apache License, Version 2.0</name>\n      <url>http://www.apache.org/licenses/LICENSE-2.0</url>\n    </license>\n  </licenses>\n  <scm>\n    <url>https://github.com/puppetlabs/jruby-utils</url>\n    <connection>scm:git:git://github.com/puppetlabs/jruby-utils.git</connection>\n    <developerConnection>scm:git:ssh://git@github.com/puppetlabs/jruby-utils.git</developerConnection>\n    <tag>04bc59704bddc388de00c54ba8f537f6081456a1</tag>\n  </scm>\n  <build>\n    <sourceDirectory>src/clj</sourceDirectory>\n    <testSourceDirectory>test/unit</testSourceDirectory>\n    <resources>\n      <resource>\n        <directory>resources</directory>\n      </resource>\n    </resources>\n    <testResources>\n      <testResource>\n        <directory>resources</directory>\n      </testResource>\n    </testResources>\n    <directory>target</directory>\n    <outputDirectory>target/classes</outputDirectory>\n    <plugins>\n      <plugin>\n        <groupId>org.codehaus.mojo</groupId>\n        <artifactId>build-helper-maven-plugin</artifactId>\n        <version>1.7</version>\n        <executions>\n          <execution>\n            <id>add-source</id>\n            <phase>generate-sources</phase>\n            <goals>\n              <goal>add-source</goal>\n            </goals>\n            <configuration>\n              <sources>\n                <source>src/java</source>\n              </sources>\n            </configuration>\n          </execution>\n          <execution>\n            <id>add-test-source</id>\n            <phase>generate-test-sources</phase>\n            <goals>\n              <goal>add-test-source</goal>\n            </goals>\n            <configuration>\n              <sources>\n                <source>test/integration</source>\n              </sources>\n            </configuration>\n          </execution>\n        </executions>\n      </plugin>\n    </plugins>\n  </build>\n  <repositories>\n    <repository>\n      <id>central</id>\n      <url>https://repo1.maven.org/maven2/</url>\n      <snapshots>\n        <enabled>false</enabled>\n      </snapshots>\n      <releases>\n        <enabled>true</enabled>\n      </releases>\n    </repository>\n    <repository>\n      <id>clojars</id>\n      <url>https://repo.clojars.org/</url>\n      <snapshots>\n        <enabled>true</enabled>\n      </snapshots>\n      <releases>\n        <enabled>true</enabled>\n      </releases>\n    </repository>\n  </repositories>\n  <dependencyManagement>\n    <dependencies>\n      <dependency>\n        <groupId>org.clojure</groupId>\n        <artifactId>clojure</artifactId>\n        <version>1.11.1</version>\n      </dependency>\n      <dependency>\n        <groupId>org.clojure</groupId>\n        <artifactId>clojurescript</artifactId>\n        <version>1.10.866</version>\n      </dependency>\n      <dependency>\n        <groupId>org.clojure</groupId>\n        <artifactId>tools.logging</artifactId>\n        <version>1.2.4</version>\n      </dependency>\n      <dependency>\n        <groupId>org.clojure</groupId>\n        <artifactId>tools.cli</artifactId>\n        <version>1.0.206</version>\n      </dependency>\n      <dependency>\n        <groupId>org.clojure</groupId>\n        <artifactId>tools.nrepl</artifactId>\n        <version>0.2.13</version>\n      </dependency>\n      <dependency>\n        <groupId>org.clojure</groupId>\n        <artifactId>tools.macro</artifactId>\n        <version>0.1.5</version>\n      </dependency>\n      <dependency>\n        <groupId>org.clojure</groupId>\n        <artifactId>java.classpath</artifactId>\n        <version>1.0.0</version>\n      </dependency>\n      <dependency>\n        <groupId>org.clojure</groupId>\n        <artifactId>java.jdbc</artifactId>\n        <version>0.7.12</version>\n      </dependency>\n      <dependency>\n        <groupId>org.clojure</groupId>\n        <artifactId>java.jmx</artifactId>\n        <version>1.0.0</version>\n      </dependency>\n      <dependency>\n        <groupId>org.clojure</groupId>\n        <artifactId>core.async</artifactId>\n        <version>1.5.648</version>\n      </dependency>\n      <dependency>\n        <groupId>org.clojure</groupId>\n        <artifactId>core.cache</artifactId>\n        <version>1.0.225</version>\n      </dependency>\n      <dependency>\n        <groupId>org.clojure</groupId>\n        <artifactId>core.memoize</artifactId>\n        <version>1.0.257</version>\n      </dependency>\n      <dependency>\n        <groupId>org.clojure</groupId>\n        <artifactId>tools.reader</artifactId>\n        <version>1.3.6</version>\n      </dependency>\n      <dependency>\n        <groupId>org.clojure</groupId>\n        <artifactId>tools.namespace</artifactId>\n        <version>0.2.11</version>\n      </dependency>\n      <dependency>\n        <groupId>org.clojure</groupId>\n        <artifactId>data.json</artifactId>\n        <version>2.4.0</version>\n      </dependency>\n      <dependency>\n        <groupId>org.clojure</groupId>\n        <artifactId>data.priority-map</artifactId>\n        <version>1.1.0</version>\n      </dependency>\n      <dependency>\n        <groupId>org.slf4j</groupId>\n        <artifactId>log4j-over-slf4j</artifactId>\n        <version>2.0.7</version>\n      </dependency>\n      <dependency>\n        <groupId>org.slf4j</groupId>\n        <artifactId>slf4j-api</artifactId>\n        <version>2.0.7</version>\n      </dependency>\n      <dependency>\n        <groupId>org.slf4j</groupId>\n        <artifactId>jul-to-slf4j</artifactId>\n        <version>2.0.7</version>\n      </dependency>\n      <dependency>\n        <groupId>ch.qos.logback</groupId>\n        <artifactId>logback-classic</artifactId>\n        <version>1.3.7</version>\n      </dependency>\n      <dependency>\n        <groupId>ch.qos.logback</groupId>\n        <artifactId>logback-core</artifactId>\n        <version>1.3.7</version>\n      </dependency>\n      <dependency>\n        <groupId>ch.qos.logback</groupId>\n        <artifactId>logback-access</artifactId>\n        <version>1.3.7</version>\n      </dependency>\n      <dependency>\n        <groupId>net.logstash.logback</groupId>\n        <artifactId>logstash-logback-encoder</artifactId>\n        <version>7.3</version>\n      </dependency>\n      <dependency>\n        <groupId>org.codehaus.janino</groupId>\n        <artifactId>janino</artifactId>\n        <version>3.0.8</version>\n      </dependency>\n      <dependency>\n        <groupId>com.fasterxml.jackson.core</groupId>\n        <artifactId>jackson-core</artifactId>\n        <version>2.14.0</version>\n      </dependency>\n      <dependency>\n        <groupId>com.fasterxml.jackson.core</groupId>\n        <artifactId>jackson-databind</artifactId>\n        <version>2.14.0</version>\n      </dependency>\n      <dependency>\n        <groupId>com.fasterxml.jackson.module</groupId>\n        <artifactId>jackson-module-afterburner</artifactId>\n        <version>2.14.0</version>\n      </dependency>\n      <dependency>\n        <groupId>org.yaml</groupId>\n        <artifactId>snakeyaml</artifactId>\n        <version>1.33</version>\n      </dependency>\n      <dependency>\n        <groupId>org.apache.maven.wagon</groupId>\n        <artifactId>wagon-provider-api</artifactId>\n        <version>2.10</version>\n      </dependency>\n      <dependency>\n        <groupId>org.apache.commons</groupId>\n        <artifactId>commons-exec</artifactId>\n        <version>1.3</version>\n      </dependency>\n      <dependency>\n        <groupId>org.apache.commons</groupId>\n        <artifactId>commons-compress</artifactId>\n        <version>1.21</version>\n      </dependency>\n      <dependency>\n        <groupId>org.apache.commons</groupId>\n        <artifactId>commons-lang3</artifactId>\n        <version>3.4</version>\n      </dependency>\n      <dependency>\n        <groupId>org.apache.httpcomponents</groupId>\n        <artifactId>httpclient</artifactId>\n        <version>4.5.13</version>\n      </dependency>\n      <dependency>\n        <groupId>org.apache.httpcomponents</groupId>\n        <artifactId>httpcore</artifactId>\n        <version>4.4.15</version>\n      </dependency>\n      <dependency>\n        <groupId>org.apache.httpcomponents</groupId>\n        <artifactId>httpasyncclient</artifactId>\n        <version>4.1.5</version>\n      </dependency>\n      <dependency>\n        <groupId>commons-beanutils</groupId>\n        <artifactId>commons-beanutils</artifactId>\n        <version>1.9.4</version>\n      </dependency>\n      <dependency>\n        <groupId>commons-codec</groupId>\n        <artifactId>commons-codec</artifactId>\n        <version>1.15</version>\n      </dependency>\n      <dependency>\n        <groupId>commons-collections</groupId>\n        <artifactId>commons-collections</artifactId>\n        <version>3.2.2</version>\n      </dependency>\n      <dependency>\n        <groupId>commons-lang</groupId>\n        <artifactId>commons-lang</artifactId>\n        <version>2.6</version>\n      </dependency>\n      <dependency>\n        <groupId>commons-logging</groupId>\n        <artifactId>commons-logging</artifactId>\n        <version>1.2</version>\n      </dependency>\n      <dependency>\n        <groupId>commons-io</groupId>\n        <artifactId>commons-io</artifactId>\n        <version>2.8.0</version>\n      </dependency>\n      <dependency>\n        <groupId>joda-time</groupId>\n        <artifactId>joda-time</artifactId>\n        <version>2.12.5</version>\n      </dependency>\n      <dependency>\n        <groupId>com.taoensso</groupId>\n        <artifactId>nippy</artifactId>\n        <version>3.1.1</version>\n      </dependency>\n      <dependency>\n        <groupId>com.taoensso</groupId>\n        <artifactId>encore</artifactId>\n        <version>3.9.2</version>\n      </dependency>\n      <dependency>\n        <groupId>nrepl</groupId>\n        <artifactId>nrepl</artifactId>\n        <version>0.6.0</version>\n      </dependency>\n      <dependency>\n        <groupId>bidi</groupId>\n        <artifactId>bidi</artifactId>\n        <version>2.1.3</version>\n      </dependency>\n      <dependency>\n        <groupId>clj-time</groupId>\n        <artifactId>clj-time</artifactId>\n        <version>0.11.0</version>\n      </dependency>\n      <dependency>\n        <groupId>clj-stacktrace</groupId>\n        <artifactId>clj-stacktrace</artifactId>\n        <version>0.2.8</version>\n      </dependency>\n      <dependency>\n        <groupId>com.zaxxer</groupId>\n        <artifactId>HikariCP</artifactId>\n        <version>5.0.1</version>\n      </dependency>\n      <dependency>\n        <groupId>clj-commons</groupId>\n        <artifactId>fs</artifactId>\n        <version>1.6.307</version>\n      </dependency>\n      <dependency>\n        <groupId>instaparse</groupId>\n        <artifactId>instaparse</artifactId>\n        <version>1.4.1</version>\n      </dependency>\n      <dependency>\n        <groupId>slingshot</groupId>\n        <artifactId>slingshot</artifactId>\n        <version>0.12.2</version>\n      </dependency>\n      <dependency>\n        <groupId>cheshire</groupId>\n        <artifactId>cheshire</artifactId>\n        <version>5.10.2</version>\n      </dependency>\n      <dependency>\n        <groupId>compojure</groupId>\n        <artifactId>compojure</artifactId>\n        <version>1.5.0</version>\n      </dependency>\n      <dependency>\n        <groupId>quoin</groupId>\n        <artifactId>quoin</artifactId>\n        <version>0.1.2</version>\n      </dependency>\n      <dependency>\n        <groupId>ring</groupId>\n        <artifactId>ring-servlet</artifactId>\n        <version>1.8.2</version>\n      </dependency>\n      <dependency>\n        <groupId>ring</groupId>\n        <artifactId>ring-core</artifactId>\n        <version>1.8.2</version>\n      </dependency>\n      <dependency>\n        <groupId>ring</groupId>\n        <artifactId>ring-codec</artifactId>\n        <version>1.1.2</version>\n      </dependency>\n      <dependency>\n        <groupId>ring</groupId>\n        <artifactId>ring-json</artifactId>\n        <version>0.5.1</version>\n      </dependency>\n      <dependency>\n        <groupId>ring-basic-authentication</groupId>\n        <artifactId>ring-basic-authentication</artifactId>\n        <version>1.1.0</version>\n      </dependency>\n      <dependency>\n        <groupId>ring</groupId>\n        <artifactId>ring-mock</artifactId>\n        <version>0.4.0</version>\n      </dependency>\n      <dependency>\n        <groupId>stencil</groupId>\n        <artifactId>stencil</artifactId>\n        <version>0.5.0</version>\n      </dependency>\n      <dependency>\n        <groupId>beckon</groupId>\n        <artifactId>beckon</artifactId>\n        <version>0.1.1</version>\n      </dependency>\n      <dependency>\n        <groupId>hiccup</groupId>\n        <artifactId>hiccup</artifactId>\n        <version>1.0.5</version>\n      </dependency>\n      <dependency>\n        <groupId>liberator</groupId>\n        <artifactId>liberator</artifactId>\n        <version>0.15.2</version>\n      </dependency>\n      <dependency>\n        <groupId>org.tcrawley</groupId>\n        <artifactId>dynapath</artifactId>\n        <version>0.2.5</version>\n      </dependency>\n      <dependency>\n        <groupId>trptcolin</groupId>\n        <artifactId>versioneer</artifactId>\n        <version>0.2.0</version>\n      </dependency>\n      <dependency>\n        <groupId>io.dropwizard.metrics</groupId>\n        <artifactId>metrics-core</artifactId>\n        <version>3.2.2</version>\n      </dependency>\n      <dependency>\n        <groupId>io.dropwizard.metrics</groupId>\n        <artifactId>metrics-graphite</artifactId>\n        <version>3.2.2</version>\n      </dependency>\n      <dependency>\n        <groupId>metrics-clojure</groupId>\n        <artifactId>metrics-clojure</artifactId>\n        <version>2.10.0</version>\n      </dependency>\n      <dependency>\n        <groupId>org.ow2.asm</groupId>\n        <artifactId>asm-all</artifactId>\n        <version>5.0.3</version>\n      </dependency>\n      <dependency>\n        <groupId>honeysql</groupId>\n        <artifactId>honeysql</artifactId>\n        <version>1.0.461</version>\n      </dependency>\n      <dependency>\n        <groupId>com.github.seancorfield</groupId>\n        <artifactId>honeysql</artifactId>\n        <version>2.3.911</version>\n      </dependency>\n      <dependency>\n        <groupId>org.postgresql</groupId>\n        <artifactId>postgresql</artifactId>\n        <version>42.4.3</version>\n      </dependency>\n      <dependency>\n        <groupId>medley</groupId>\n        <artifactId>medley</artifactId>\n        <version>1.0.0</version>\n      </dependency>\n      <dependency>\n        <groupId>prismatic</groupId>\n        <artifactId>plumbing</artifactId>\n        <version>0.4.2</version>\n      </dependency>\n      <dependency>\n        <groupId>prismatic</groupId>\n        <artifactId>schema</artifactId>\n        <version>1.1.12</version>\n      </dependency>\n      <dependency>\n        <groupId>stylefruits</groupId>\n        <artifactId>gniazdo</artifactId>\n        <version>1.2.1</version>\n      </dependency>\n      <dependency>\n        <groupId>puppetlabs</groupId>\n        <artifactId>http-client</artifactId>\n        <version>2.1.1</version>\n      </dependency>\n      <dependency>\n        <groupId>puppetlabs</groupId>\n        <artifactId>jdbc-util</artifactId>\n        <version>1.4.0</version>\n      </dependency>\n      <dependency>\n        <groupId>puppetlabs</groupId>\n        <artifactId>typesafe-config</artifactId>\n        <version>0.2.0</version>\n      </dependency>\n      <dependency>\n        <groupId>puppetlabs</groupId>\n        <artifactId>ssl-utils</artifactId>\n        <version>3.5.2</version>\n      </dependency>\n      <dependency>\n        <groupId>puppetlabs</groupId>\n        <artifactId>clj-ldap</artifactId>\n        <version>0.4.0</version>\n      </dependency>\n      <dependency>\n        <groupId>puppetlabs</groupId>\n        <artifactId>kitchensink</artifactId>\n        <version>3.2.1</version>\n      </dependency>\n      <dependency>\n        <groupId>puppetlabs</groupId>\n        <artifactId>kitchensink</artifactId>\n        <version>3.2.1</version>\n        <classifier>test</classifier>\n      </dependency>\n      <dependency>\n        <groupId>puppetlabs</groupId>\n        <artifactId>trapperkeeper</artifactId>\n        <version>3.3.1</version>\n      </dependency>\n      <dependency>\n        <groupId>puppetlabs</groupId>\n        <artifactId>trapperkeeper</artifactId>\n        <version>3.3.1</version>\n        <classifier>test</classifier>\n      </dependency>\n      <dependency>\n        <groupId>puppetlabs</groupId>\n        <artifactId>trapperkeeper-webserver-jetty9</artifactId>\n        <version>4.5.1</version>\n      </dependency>\n      <dependency>\n        <groupId>puppetlabs</groupId>\n        <artifactId>trapperkeeper-webserver-jetty9</artifactId>\n        <version>4.5.1</version>\n        <classifier>test</classifier>\n      </dependency>\n      <dependency>\n        <groupId>puppetlabs</groupId>\n        <artifactId>trapperkeeper-metrics</artifactId>\n        <version>1.5.1</version>\n      </dependency>\n      <dependency>\n        <groupId>puppetlabs</groupId>\n        <artifactId>trapperkeeper-metrics</artifactId>\n        <version>1.5.1</version>\n        <classifier>test</classifier>\n      </dependency>\n      <dependency>\n        <groupId>puppetlabs</groupId>\n        <artifactId>trapperkeeper-scheduler</artifactId>\n        <version>1.1.3</version>\n      </dependency>\n      <dependency>\n        <groupId>puppetlabs</groupId>\n        <artifactId>trapperkeeper-authorization</artifactId>\n        <version>1.0.0</version>\n      </dependency>\n      <dependency>\n        <groupId>puppetlabs</groupId>\n        <artifactId>trapperkeeper-status</artifactId>\n        <version>1.1.2</version>\n      </dependency>\n      <dependency>\n        <groupId>puppetlabs</groupId>\n        <artifactId>trapperkeeper-filesystem-watcher</artifactId>\n        <version>1.2.2</version>\n      </dependency>\n      <dependency>\n        <groupId>puppetlabs</groupId>\n        <artifactId>structured-logging</artifactId>\n        <version>0.2.0</version>\n      </dependency>\n      <dependency>\n        <groupId>puppetlabs</groupId>\n        <artifactId>ring-middleware</artifactId>\n        <version>1.3.1</version>\n      </dependency>\n      <dependency>\n        <groupId>puppetlabs</groupId>\n        <artifactId>dujour-version-check</artifactId>\n        <version>1.0.0</version>\n      </dependency>\n      <dependency>\n        <groupId>puppetlabs</groupId>\n        <artifactId>comidi</artifactId>\n        <version>1.0.0</version>\n      </dependency>\n      <dependency>\n        <groupId>puppetlabs</groupId>\n        <artifactId>trapperkeeper-comidi-metrics</artifactId>\n        <version>0.1.1</version>\n      </dependency>\n      <dependency>\n        <groupId>puppetlabs</groupId>\n        <artifactId>i18n</artifactId>\n        <version>0.9.2</version>\n      </dependency>\n      <dependency>\n        <groupId>puppetlabs</groupId>\n        <artifactId>cljs-dashboard-widgets</artifactId>\n        <version>0.1.0</version>\n      </dependency>\n      <dependency>\n        <groupId>puppetlabs</groupId>\n        <artifactId>rbac-client</artifactId>\n        <version>1.1.4</version>\n      </dependency>\n      <dependency>\n        <groupId>puppetlabs</groupId>\n        <artifactId>rbac-client</artifactId>\n        <version>1.1.4</version>\n        <classifier>test</classifier>\n      </dependency>\n      <dependency>\n        <groupId>puppetlabs</groupId>\n        <artifactId>analytics-client</artifactId>\n        <version>1.2.0</version>\n      </dependency>\n      <dependency>\n        <groupId>puppetlabs</groupId>\n        <artifactId>clj-shell-utils</artifactId>\n        <version>1.0.2</version>\n      </dependency>\n      <dependency>\n        <groupId>puppetlabs</groupId>\n        <artifactId>jruby-utils</artifactId>\n        <version>4.0.3</version>\n      </dependency>\n      <dependency>\n        <groupId>org.bouncycastle</groupId>\n        <artifactId>bcpkix-fips</artifactId>\n        <version>1.0.7</version>\n      </dependency>\n      <dependency>\n        <groupId>org.bouncycastle</groupId>\n        <artifactId>bc-fips</artifactId>\n        <version>1.0.2.4</version>\n      </dependency>\n      <dependency>\n        <groupId>org.bouncycastle</groupId>\n        <artifactId>bctls-fips</artifactId>\n        <version>1.0.17</version>\n      </dependency>\n      <dependency>\n        <groupId>org.bouncycastle</groupId>\n        <artifactId>bcpkix-jdk18on</artifactId>\n        <version>1.74</version>\n      </dependency>\n      <dependency>\n        <groupId>org.bouncycastle</groupId>\n        <artifactId>bctls-jdk18on</artifactId>\n        <version>1.74</version>\n      </dependency>\n      <dependency>\n        <groupId>org.bouncycastle</groupId>\n        <artifactId>bcprov-jdk18on</artifactId>\n        <version>1.74</version>\n      </dependency>\n      <dependency>\n        <groupId>org.bouncycastle</groupId>\n        <artifactId>bcutil-jdk18on</artifactId>\n        <version>1.74</version>\n      </dependency>\n    </dependencies>\n  </dependencyManagement>\n  <dependencies>\n    <dependency>\n      <groupId>org.clojure</groupId>\n      <artifactId>clojure</artifactId>\n    </dependency>\n    <dependency>\n      <groupId>org.clojure</groupId>\n      <artifactId>java.jmx</artifactId>\n    </dependency>\n    <dependency>\n      <groupId>org.clojure</groupId>\n      <artifactId>tools.logging</artifactId>\n    </dependency>\n    <dependency>\n      <groupId>clj-commons</groupId>\n      <artifactId>fs</artifactId>\n    </dependency>\n    <dependency>\n      <groupId>prismatic</groupId>\n      <artifactId>schema</artifactId>\n    </dependency>\n    <dependency>\n      <groupId>slingshot</groupId>\n      <artifactId>slingshot</artifactId>\n    </dependency>\n    <dependency>\n      <groupId>puppetlabs</groupId>\n      <artifactId>jruby-deps</artifactId>\n      <version>9.3.14.0-1</version>\n    </dependency>\n    <dependency>\n      <groupId>puppetlabs</groupId>\n      <artifactId>i18n</artifactId>\n    </dependency>\n    <dependency>\n      <groupId>puppetlabs</groupId>\n      <artifactId>kitchensink</artifactId>\n    </dependency>\n    <dependency>\n      <groupId>puppetlabs</groupId>\n      <artifactId>trapperkeeper</artifactId>\n    </dependency>\n    <dependency>\n      <groupId>puppetlabs</groupId>\n      <artifactId>ring-middleware</artifactId>\n    </dependency>\n    <dependency>\n      <groupId>puppetlabs</groupId>\n      <artifactId>kitchensink</artifactId>\n      <classifier>test</classifier>\n      <scope>test</scope>\n    </dependency>\n    <dependency>\n      <groupId>puppetlabs</groupId>\n      <artifactId>trapperkeeper</artifactId>\n      <classifier>test</classifier>\n      <scope>test</scope>\n    </dependency>\n    <dependency>\n      <groupId>org.bouncycastle</groupId>\n      <artifactId>bcpkix-jdk18on</artifactId>\n      <scope>test</scope>\n    </dependency>\n    <dependency>\n      <groupId>org.tcrawley</groupId>\n      <artifactId>dynapath</artifactId>\n      <scope>test</scope>\n    </dependency>\n  </dependencies>\n</project>\n\n<!-- This file was autogenerated by Leiningen.\n  Please do not edit it directly; instead edit project.clj and regenerate it.\n  It should not be considered canonical data. For more information see\n  https://github.com/technomancy/leiningen -->\n"}