oio.event package

Subpackages

• oio.event.filters package
  • Submodules
  • oio.event.filters.account_update module
  • oio.event.filters.base module
  • oio.event.filters.bury module
  • oio.event.filters.content_cleaner module
  • oio.event.filters.dump module
  • oio.event.filters.logger module
  • oio.event.filters.noop module
  • oio.event.filters.notify module
  • oio.event.filters.replicate module
  • oio.event.filters.volume_index module
  • oio.event.filters.webhook module
  • oio.event.filters.xcute module
  • Module contents
• oio.event.handlers package
  • Submodules
  • oio.event.handlers.base module
  • Module contents

Submodules

oio.event.agent module

exception oio.event.agent.HaltServer(reason, exit_status=1)

Bases: exceptions.BaseException

class oio.event.agent.Runner(conf_file, worker_class, **kwargs)

Bases: object

SIGNALS = [1, 3, 2, 15]

SIG_NAMES = {1: 'hup', 2: 'int', 3: 'quit', 4: 'ill', 5: 'trap', 6: 'iot', 7: 'bus', 8: 'fpe', 9: 'kill', 10: 'usr1', 11: 'segv', 12: 'usr2', 13: 'pipe', 14: 'alrm', 15: 'term', 17: 'cld', 18: 'cont', 19: 'stop', 20: 'tstp', 21: 'ttin', 22: 'ttou', 23: 'urg', 24: 'xcpu', 25: 'xfsz', 26: 'vtalrm', 27: 'prof', 28: 'winch', 29: 'poll', 30: 'pwr', 31: 'sys', 34: 'rtmin', 64: 'rtmax'}

WORKER_START_ERROR = 3

configure_signals()

halt(reason=None, exit_status=0)

handle_chld(sig, frame)

handle_hup()

handle_int()

handle_quit()

handle_term()

kill_worker(pid, sig)

kill_workers(sig)

manage_workers()

reap_workers()

run()

signal(sig, frame)

spawn_worker()

spawn_workers()

start()

stop(graceful=True)

x = 'TERM'

oio.event.agent.validate_msg(msg)

oio.event.beanstalk module

class oio.event.beanstalk.BaseParser(socket_read_size)

Bases: object

can_read()

on_connect(connection)

on_disconnect()

read(size)

read_response()

class oio.event.beanstalk.Beanstalk(host=None, port=None, socket_timeout=None, socket_connect_timeout=None, socket_keepalive=None, socket_keepalive_options=None, connection=None, **kwargs)

Bases: object

EXPECTED_ERR = {'bury': ['NOT_FOUND', 'OUT_OF_MEMORY'], 'delete': ['NOT_FOUND'], 'kick': ['OUT_OF_MEMORY'], 'kick-job': ['NOT_FOUND', 'OUT_OF_MEMORY'], 'list-tubes': [], 'peek': ['NOT_FOUND'], 'peek-buried': ['NOT_FOUND'], 'peek-delayed': ['NOT_FOUND'], 'peek-ready': ['NOT_FOUND'], 'put': ['JOB_TOO_BIG', 'BURIED', 'DRAINING', 'OUT_OF_MEMORY'], 'release': ['BURIED', 'NOT_FOUND', 'OUT_OF_MEMORY'], 'reserve': ['DEADLINE_SOON', 'TIMED_OUT'], 'reserve-with-timeout': ['DEADLINE_SOON', 'TIMED_OUT'], 'stats': [], 'stats-tube': ['NOT_FOUND'], 'use': [], 'watch': []}

EXPECTED_OK = {'bury': ['BURIED'], 'delete': ['DELETED'], 'kick': ['KICKED'], 'kick-job': ['KICKED'], 'list-tubes': ['OK'], 'peek': ['FOUND'], 'peek-buried': ['FOUND'], 'peek-delayed': ['FOUND'], 'peek-ready': ['FOUND'], 'put': ['INSERTED'], 'release': ['RELEASED'], 'reserve': ['RESERVED'], 'reserve-with-timeout': ['RESERVED'], 'stats': ['OK'], 'stats-tube': ['OK'], 'use': ['USING'], 'watch': ['WATCHING']}

RESPONSE_CALLBACKS = {'list-tubes': <function parse_yaml at 0x7fdf92a64398>, 'peek': <function parse_body at 0x7fdf92a64410>, 'peek-buried': <function parse_body at 0x7fdf92a64410>, 'peek-delayed': <function parse_body at 0x7fdf92a64410>, 'peek-ready': <function parse_body at 0x7fdf92a64410>, 'reserve': <function parse_body at 0x7fdf92a64410>, 'reserve-with-timeout': <function parse_body at 0x7fdf92a64410>, 'stats': <function parse_yaml at 0x7fdf92a64398>, 'stats-tube': <function parse_yaml at 0x7fdf92a64398>}

bury(job_id, priority=2147483648)

close()

delete(job_id)

drain_buried(tube)

drain_tube(tube, timeout=0.0)

Delete all jobs from the specified tube.

execute_command(*args, **kwargs)

classmethod from_url(url, **kwargs)

kick(bound=1000)

Move jobs into the ready queue. If there are any buried jobs, it will only kick buried jobs. Otherwise it will kick delayed jobs.

Parameters:bound (int) – upper bound on the number of jobs to kick

kick_job(job_id)

Variant of` kick` that operates with a single job.

Parameters:job_id (str) – the job id to kick

parse_response(connection, command_name, **kwargs)

peek_buried()

Read the next buried job without kicking it.

peek_ready()

read the next ready job without reserving it.

put(body, priority=2147483648, delay=0, ttr=120)

release(job_id, priority=2147483648, delay=0)

reserve(timeout=None)

stats()

stats_tube(tube)

tubes()

use(tube)

wait_for_ready_job(tube, timeout=inf, poll_interval=0.2)

Wait until the the specified tube has a ready job, or the timeout expires.

wait_until_empty(tube, timeout=inf, poll_interval=0.2, initial_delay=0.0)

Wait until the the specified tube is empty, or the timeout expires.

watch(tube)

exception oio.event.beanstalk.BeanstalkError

Bases: exceptions.Exception

class oio.event.beanstalk.BeanstalkdListener(addr, tube, logger, **kwargs)

Bases: oio.event.beanstalk.TubedBeanstalkd

fetch_job(on_job, timeout=None, **kwargs)

fetch_jobs(on_job, reserve_timeout=None, **kwargs)

class oio.event.beanstalk.BeanstalkdSender(addr, tube, logger, low_limit=512, high_limit=1024, **kwargs)

Bases: oio.event.beanstalk.TubedBeanstalkd

Send jobs to the specified beanstalkd tube, until the specified high_limit is reached.

job_done()

Declare that a job previously sent by this sender has been fully processed (the sender received a response, or does not expect one).

send_event(event, **kwargs)

Deprecated

send_job(job, priority=2147483648, delay=0, **kwargs)

Send a job, if the queue has not reached its size limit.

Returns:True if the job has been sent, False otherwise.

class oio.event.beanstalk.Connection(host=None, port=None, use_tubes=None, watch_tubes=None, socket_timeout=None, socket_connect_timeout=None, socket_keepalive=False, socket_keepalive_options=None, encoding='utf-8', socket_read_size=65536)

Bases: object

connect()

disconnect()

classmethod from_url(url, **kwargs)

on_connect()

pack_command(command, body, *args)

read_body(size)

read_response()

send_command(command, *args, **kwargs)

use(tube)

watch(tube)

exception oio.event.beanstalk.ConnectionError

Bases: oio.event.beanstalk.BeanstalkError

exception oio.event.beanstalk.InvalidResponse

Bases: oio.event.beanstalk.BeanstalkError

class oio.event.beanstalk.Reader(socket, socket_read_size)

Bases: object

close()

length

purge()

read(length)

readline()

exception oio.event.beanstalk.ResponseError

Bases: oio.event.beanstalk.BeanstalkError

exception oio.event.beanstalk.TimeoutError

Bases: oio.event.beanstalk.BeanstalkError

class oio.event.beanstalk.TubedBeanstalkd(addr, tube, logger, **kwargs)

Bases: object

Beanstalkd wrapper that will talk to a single tube.

close()

Disconnect the wrapped Beanstalkd client.

oio.event.beanstalk.dict_merge(*dicts)

oio.event.beanstalk.parse_body(connection, response, **kwargs)

oio.event.beanstalk.parse_yaml(connection, response, **kwargs)

oio.event.client module

class oio.event.client.EventClient(conf, **kwargs)

Bases: object

beanstalk

exhume(limit=1000, tube=None)

Move buried or delayed jobs into the ready queue.

stats(tube=None)

oio.event.consumer module

class oio.event.consumer.EventWorker(*args, **kwargs)

Bases: oio.event.consumer.Worker

get_handler(event)

handle(beanstalk)

init()

notify()

TODO

process_event(job_id, event, beanstalk)

run()

safe_decode_job(job_id, data)

exception oio.event.consumer.StopServe

Bases: exceptions.Exception

class oio.event.consumer.Worker(ppid, conf, logger)

Bases: object

SIGNALS = [1, 3, 2, 15, 17]

handle_exit(sig, frame)

handle_quit(sig, frame)

init()

init_signals()

parent_alive()

pid

run()

x = 'CHLD'

oio.event.evob module

class oio.event.evob.Event(env)

Bases: object

data

event_type

job_id

reqid

url

when

exception oio.event.evob.EventException(*args, **kwargs)

Bases: oio.event.evob.Response, exceptions.Exception

class oio.event.evob.EventTypes

Bases: object

Enum class for event type names.

ACCOUNT_SERVICES = 'account.services'

CHUNK_DELETED = 'storage.chunk.deleted'

CHUNK_NEW = 'storage.chunk.new'

CONTAINER_DELETED = 'storage.container.deleted'

CONTAINER_EVENTS = ('storage.container.deleted', 'storage.container.new', 'storage.container.state', 'storage.container.update')

CONTAINER_NEW = 'storage.container.new'

CONTAINER_STATE = 'storage.container.state'

CONTAINER_UPDATE = 'storage.container.update'

CONTENT_APPEND = 'storage.content.append'

CONTENT_BROKEN = 'storage.content.broken'

CONTENT_DELETED = 'storage.content.deleted'

CONTENT_EVENTS = ('storage.content.append', 'storage.content.broken', 'storage.content.deleted', 'storage.content.new', 'storage.content.perfectible', 'storage.content.rebuilt', 'storage.content.update')

CONTENT_NEW = 'storage.content.new'

CONTENT_PERFECTIBLE = 'storage.content.perfectible'

CONTENT_REBUILT = 'storage.content.rebuilt'

CONTENT_UPDATE = 'storage.content.update'

META2_DELETED = 'storage.meta2.deleted'

XCUTE_TASKS = 'xcute.tasks'

class oio.event.evob.Response(body=None, status=200, event=None, **kwargs)

Bases: object

class oio.event.evob.StatusMap

Bases: object

oio.event.evob.is_error(status)

oio.event.evob.is_success(status)

oio.event.loader module

class oio.event.loader.AttrDict

Bases: dict

class oio.event.loader.ConfigLoader(filename)

Bases: object

absolute_name(name)

find_config_section(obj_type, name=None)

get_context(obj_type, name=None, global_conf=None)

get_sections(prefix=None)

class oio.event.loader.CustomConfigParser(filename, *args, **kwargs)

Bases: ConfigParser.ConfigParser

class oio.event.loader.EggLoader(spec)

Bases: oio.event.loader._Loader

find_egg_ep(obj_type, name=None)

get_context(obj_type, name=None, global_conf=None)

class oio.event.loader.LoaderContext(obj, obj_type, protocol, global_conf, local_conf, loader, distribution=None, ep_name=None)

Bases: object

config()

create(**kwargs)

oio.event.loader.loadcontext(obj_type, uri, name=None, global_conf=None)

oio.event.loader.loadhandler(loader, name, global_conf=None, **kwargs)

oio.event.loader.loadhandlers(path, global_conf=None, **kwargs)

Module contents