def __init__(self, request):
if hasattr(request, 'connection'):
self.conn = Connection(request.connection[0], request.connection[1])
elif settings.BEANSTALK_SERVERS:
server = settings.BEANSTALK_SERVERS[0]
self.conn = Connection(server[0], server[1])
else:
raise Exception("No servers defined.")
def test_basic(self):
conn = Connection("database")
q = conn.Queue("testing")
self.assertRaises(Empty, q.get)
q.put(serialize({"name": "George Constanza"}))
self.assertEquals(deserialize(q.get()), {"name": "George Constanza"})
def _ensure_connect(self):
if self.__bs is None:
print 'beanstalkc client connecting ...'
self.__bs = Connection(self.__host, self.__port)
print 'beanstalkc client connected to %s:%s:[%s]' % (
self.__host, self.__port, self.__tube)
if not self.__tube is None:
self.__bs.use(self.__tube)
print 'beanstalkc client using %s' % self.__bs.using()
def establish_connection(self):
conninfo = self.connection
conn = Connection(self.type,
host=conninfo.hostname,
user=conninfo.userid,
password=conninfo.password,
database=conninfo.virtual_host,
port=conninfo.port)
conn.drain_events = self.drain_events
return conn
def connect(self):
while True:
try:
self.__bs = Connection(self.__host, self.__port)
print 'connected to %s:%s' % (self.__host, self.__port)
self.__bs.watch(self.__tube)
print 'watching %s' % self.__bs.watching()
if not self.__bs is None:
return
except:
time.sleep(1)
def establish_connection(self):
self.port = self.port or DEFAULT_PORT
self.host = self.host or DEFAULT_HOST
self.connection = Connection(host=self.host, port=self.port)
dbname = self.database
if not dbname or dbname == "/":
dbname = "ghettoq"
self.database = getattr(self.connection, dbname)
col = self.database.messages
col.ensure_index([("queue", 1)])
return col
def init_app(self, app):
app.config.setdefault('BEANSTALK_HOST', '127.0.0.1')
app.config.setdefault('BEANSTALK_PORT', 11300)
if not hasattr(app, 'extensions'):
app.extensions = {}
app.extensions['beanstalk'] = _BeanstalkState(self, app)
self._client = Connection(
host=app.config.get('BEANSTALK_HOST'),
port=app.config.get('BEANSTALK_PORT'))
def connect_beanstalkd():
"""Connect to beanstalkd server(s) from settings file"""
server = getattr(settings, 'BEANSTALK_SERVER', '127.0.0.1')
port = 11300
if server.find(':') > -1:
server, port = server.split(':', 1)
try:
port = int(port)
return Connection(server, port)
except (ValueError, SocketError), e:
raise BeanstalkError(e)
def __init__(self, host, port=11300):
"""
Args:
host: host1_ip:host2_ip:...
port: 11300
"""
self.host = host
self.port = port
self.current_use_server_index = 0
self.servers = []
hosts = host.split(":")
serverlist = itertools.product(hosts, [port])
for s in serverlist:
conn = Connection(host=s[0], port=s[1], connect_timeout=20)
conn.connect()
self.servers.append(conn)
def create_connection(database):
return Connection(database)
def _open(self):
conninfo = self.connection.client
port = conninfo.port or DEFAULT_PORT
conn = Connection(host=conninfo.hostname, port=port)
conn.connect()
return conn
def queue(self, name):
return Queue(Connection(self.host, self.port), name, self.max_size)
def create_bstalk_conn():
return Connection(
host=BEANSTALKD['host'],
port=BEANSTALKD['port'],
connect_timeout=1,
)
def establish_connection(self):
self.host = self.host or DEFAULT_HOST
self.port = self.port or DEFAULT_PORT
return Connection(host=self.host, port=self.port)
def create_connection(database):
return Connection("redis", host="localhost", database=database)
def create_connection(database):
return Connection("mongodb", host="localhost", database=database)
def make_connection(self):
dsn = url_parse(self.dsn)
if dsn.scheme != 'beanstalkd':
raise ValueError('invalid beanstalkd dsn')
return Connection(host=dsn.host, port=dsn.port)
def __init__(self):
self.conn = Connection(settings.BEANSTALK_HOST,
settings.BEANSTALK_PORT)
def create_connection():
return Connection("beanstalk", host="localhost")
