class Beanstalk(object): def __init__(self, host='localhost', port=11300, **kwargs): self._connection_pool = ConnectionPool(host=host, port=port, **kwargs) def _request(self, connection, command, oks, errs): connection.client_socket.sendall(command) line = connection.socket_file.readline() if not line: raise BeanstalkConnectionError() response = line.split() status = response[0] results = response[1:] if status in oks: return results elif status in errs: raise BeanstalkCommandFailed(command.split()[0], status, response) else: raise BeanstalkUnknownError(command.split()[0], status, results) def _response(self, connection, size): body = connection.socket_file.read(size) if size > 0 and not body: raise BeanstalkConnectionError() return body def _request_value(self, command, oks, errs=()): connection = self._connection_pool.pick_connection() value = self._request(connection, command, oks, errs) self._connection_pool.release(connection) return value[0] def _request_job(self, command, oks, errs=(), reserved=True): connection = self._connection_pool.pick_connection() job_id, size = self._request(connection, command, oks, errs) body = self._response(connection, int(size)) self._connection_pool.release(connection) return Job(self, int(job_id), body, reserved) def _request_yaml(self, command, oks, errs=()): connection = self._connection_pool.pick_connection() job_id, size = self._request(connection, command, oks, errs) body = self._response(connection, int(size)) self._connection_pool.release(connection) return yaml.load(body) def _request_peek(self, command): try: return self._request_job(command, [Response.FOUND], [Response.NOT_FOUND], False) except BeanstalkCommandFailed: return None def put(self, body, priority=macro.PRIORITY, delay=0, ttr=macro.TTR): """Put a job into the current tube. Returns job id.""" assert isinstance(body, str), 'Job body must be a str instance' jid = self._request_value(Command.PUT % (priority, delay, ttr, len(body), body), (Response.INSERTED, ), (Response.JOB_TOO_BIG, Response.BURIED, Response.DRAINING)) return int(jid) def reserve(self, timeout=None): """Reserve a job from one of the watched tubes, with optional timeout in seconds. Returns a Job object, or None if the request times out.""" if timeout is not None: command = Command.RESERVE_WITH_TIMEOUT % timeout else: command = Command.RESERVE try: return self._request_job(command, (Response.RESERVED, ), (Response.DEADLINE_SOON, Response.TIMED_OUT)) except BeanstalkCommandFailed: exc = sys.exc_info()[1] _, status, results = exc.args if status == Response.TIMED_OUT: return None elif status == Response.DEADLINE_SOON: raise BeanstalkJobDeadlineSoon(results) def kick(self, bound=1): """Kick at most bound jobs into the ready queue.""" return int(self._request_value(Command.KICK % bound, (Response.KICKED, ))) def kick_job(self, jid): """Kick a specific job into the ready queue.""" self._request_value(Command.KICK_JOB % jid, (Response.KICKED, ), (Response.NOT_FOUND, )) def peek(self, jid): """Peek at a job. Returns a Job, or None.""" return self._request_peek(Command.PEEK % jid) def peek_ready(self): """Peek at next ready job. Returns a Job, or None.""" return self._request_peek(Command.PEEK_READY) def peek_delayed(self): """Peek at next delayed job. Returns a Job, or None.""" return self._request_peek(Command.PEEK_DELAYED) def peek_buried(self): """Peek at next buried job. Returns a Job, or None.""" return self._request_peek(Command.PEEK_BURIED) def tubes(self): """Return a list of all existing tubes.""" return self._request_yaml(Command.LIST_TUBES, (Response.OK, )) def using(self): """Return the tube currently being used.""" return self._request_value(Command.LIST_TUBE_USED, (Response.USING, )) def use(self, name): """Use a given tube.""" return self._request_value(Command.USE % name, (Response.USING, )) def watching(self): """Return a list of all tubes being watched.""" return self._request_yaml(Command.LIST_TUBES_WATCHED, (Response.OK, )) def watch(self, name): """Watch a given tube.""" return int(self._request_value(Command.WATCH % name, (Response.WATCHING, ))) def ignore(self, name): """Stop watching a given tube.""" try: return int(self._request_value(Command.IGNORE % name, (Response.WATCHING, ), (Response.NOT_IGNORED, ))) except BeanstalkCommandFailed: return 1 def stats(self): """Return a dict of beanstalkd statistics.""" return self._request_yaml(Command.STATS, (Response.OK, )) def stats_tube(self, name): """Return a dict of stats about a given tube.""" return self._request_yaml(Command.STATS_TUBE % name, (Response.OK, ), (Response.NOT_FOUND, )) def pause_tube(self, name, delay): """Pause a tube for a given delay time, in seconds.""" self._request_value(Command.PAUSE_TUBE % (name, delay), (Response.PAUSED, ), (Response.NOT_FOUND, )) # -- job interactors -- def delete(self, jid): """Delete a job, by job id.""" self._request_value(Command.DELETE_JOB % jid, (Response.DELETED, ), (Response.NOT_FOUND, )) def release(self, jid, priority=macro.PRIORITY, delay=0): """Release a reserved job back into the ready queue.""" self._request_value(Command.RELEASE_JOB % (jid, priority, delay), (Response.RELEASED, Response.BURIED, ), (Response.NOT_FOUND, )) def bury(self, jid, priority=macro.PRIORITY): """Bury a job, by job id.""" self._request_value(Command.BURY_JOB % (jid, priority), (Response.BURIED, ), (Response.NOT_FOUND, )) def touch(self, jid): """Touch a job, by job id, requesting more time to work on a reserved job before it expires.""" self._request_value(Command.TOUCH_JOB % jid, (Response.TOUCHED, ), (Response.NOT_FOUND, )) def stats_job(self, jid): """Return a dict of stats about a job, by job id.""" return self._request_yaml(Command.STATS_JOB % jid, (Response.OK, ), (Response.NOT_FOUND, ))