lib.redis.event — xyz.zcaudate/lib.redis 4.0.1

+actions+ clj

+default+ clj

+lu+ clj

+rlu+ clj

action:add clj

(action:add key {:keys [subscribe unsubscribe args wrap] :as m})

adds an action from registry

action:get clj

(action:get key)

gets action type

action:list clj

(action:list)

lists action types

action:remove clj

(action:remove key)

removes an action from registry

config:add clj

(config:add redis events)

(config:add redis events opts)

adds config notifications

config:get clj

(config:get redis)

(config:get redis opts)

gets the config for notifications

config:remove clj

(config:remove redis events)

(config:remove redis events opts)

removes config notifications

config:set clj

(config:set redis events)

(config:set redis events opts)

sets the config for notifications

events-parse clj

(events-parse s)

creates a set of enums from a string

events-string clj

(events-string events)

creates a string from a set of enums

has-notify clj

(has-notify redis id)

checks that a given notify listener is installed

list-notify clj

(list-notify redis)

lists all notify listeners for a client

listener-loop clj

(listener-loop conn f)

creates a listener loop

listener-string clj

(listener-string {:keys [type connection] :as listener})

string description of a listener

listener:add clj

(listener:add type redis id input handler)

(listener:add type
              {:keys [namespace runtime pool] :as redis}
              id
              input
              handler
              opts)

adds a listener to the redis client

listener:all clj

(listener:all {:keys [runtime]})

lists all listeners

listener:count clj

(listener:count {:keys [runtime]})

counts all listeners

listener:create clj

(listener:create {:keys [namespace pool] :as redis} type id input handler)

creates a listener

listener:get clj

(listener:get {:keys [runtime]} type id)

gets a client listener

(-> (doto |client| (subscribe :foo ["foo"] prn)) (listener:get :subscribe :foo)) => listener?

listener:list clj

(listener:list {:keys [runtime]})

lists all listeners

(-> (doto |client| (subscribe :foo ["foo"] prn) (psubscribe :bar "*" prn)) (listener:list)) => {:subscribe [:foo] :psubscribe [:bar]}

listener:remove clj

(listener:remove type {:keys [runtime] :as redis} id)

removes a listener from the client

listener:teardown clj

(listener:teardown {:keys [type connection] :as listener})

tears down the listener

listener? clj

(listener? obj)

checks that object is a listener

notify clj

(notify redis id pattern handler)

notifications for a given client

notify:args clj

(notify:args namespace inputs)

produces the notify args

notify:wrap clj

(notify:wrap handler {:keys [namespace] :as redis})

wrapper for the notify delivery function

psubscribe clj

(psubscribe redis id pattern handler)

subscribes to a pattern on the cache

psubscribe:wrap clj

(psubscribe:wrap handler {:keys [format] :as redis})

wrapper for the psubscribe delivery function

punsubscribe clj

(punsubscribe redis id)

unsubscribes from the pattern

start:events-redis clj

(start:events-redis redis events)

creates action for :events

start:notify-redis clj

(start:notify-redis redis listeners)

creates action for :notify

stop:notify-redis clj

(stop:notify-redis redis listeners)

stop action for :notify field

subscribe clj

(subscribe redis id channels handler)

subscribes to a channel on the cache

subscribe:wrap clj

(subscribe:wrap handler {:keys [format] :as redis})

wrapper for the subscribe delivery function

unnotify clj

(unnotify redis id)

removes notifications for a given client

unsubscribe clj

(unsubscribe redis id)

unsubscribes from a channel