def test_parse_slow_for_standard_properties(self):
HeaderFrame.DEFAULT_PROPERTIES = False
bit_writer = Writer()
val_writer = Writer()
# strip ms because amqp doesn't include it
now = datetime.utcfromtimestamp(
long(time.mktime(datetime.now().timetuple())))
bit_field = 0
for pname, ptype, reader, writer, mask in HeaderFrame.PROPERTIES:
bit_field = (bit_field << 1) | 1
if ptype == 'shortstr':
val_writer.write_shortstr(pname)
elif ptype == 'octet':
val_writer.write_octet(42)
elif ptype == 'timestamp':
val_writer.write_timestamp(now)
elif ptype == 'table':
val_writer.write_table({'foo': 'bar'})
bit_field <<= (16 - len(HeaderFrame.PROPERTIES))
bit_writer.write_short(bit_field)
header_writer = Writer()
header_writer.write_short(5)
header_writer.write_short(6)
header_writer.write_longlong(7)
payload = header_writer.buffer()
payload += bit_writer.buffer()
payload += val_writer.buffer()
reader = Reader(payload)
frame = HeaderFrame.parse(4, reader)
HeaderFrame.DEFAULT_PROPERTIES = True
for pname, ptype, reader, writer, mask in HeaderFrame.PROPERTIES:
if ptype == 'shortstr':
self.assertEquals(pname, frame.properties[pname])
elif ptype == 'octet':
self.assertEquals(42, frame.properties[pname])
elif ptype == 'timestamp':
self.assertEquals(now, frame.properties[pname])
elif ptype == 'table':
self.assertEquals({'foo': 'bar'}, frame.properties[pname])
assert_equals(4, frame.channel_id)
assert_equals(5, frame._class_id)
assert_equals(6, frame._weight)
assert_equals(7, frame._size)
def test_parse_slow_for_standard_properties(self):
HeaderFrame.DEFAULT_PROPERTIES = False
bit_writer = Writer()
val_writer = Writer()
# strip ms because amqp doesn't include it
now = datetime.utcfromtimestamp(
long(time.mktime(datetime.now().timetuple())))
bit_field = 0
for pname, ptype, reader, writer, mask in HeaderFrame.PROPERTIES:
bit_field = (bit_field << 1) | 1
if ptype == 'shortstr':
val_writer.write_shortstr(pname)
elif ptype == 'octet':
val_writer.write_octet(42)
elif ptype == 'timestamp':
val_writer.write_timestamp(now)
elif ptype == 'table':
val_writer.write_table({'foo': 'bar'})
bit_field <<= (16 - len(HeaderFrame.PROPERTIES))
bit_writer.write_short(bit_field)
header_writer = Writer()
header_writer.write_short(5)
header_writer.write_short(6)
header_writer.write_longlong(7)
payload = header_writer.buffer()
payload += bit_writer.buffer()
payload += val_writer.buffer()
reader = Reader(payload)
frame = HeaderFrame.parse(4, reader)
HeaderFrame.DEFAULT_PROPERTIES = True
for pname, ptype, reader, writer, mask in HeaderFrame.PROPERTIES:
if ptype == 'shortstr':
self.assertEquals(pname, frame.properties[pname])
elif ptype == 'octet':
self.assertEquals(42, frame.properties[pname])
elif ptype == 'timestamp':
self.assertEquals(now, frame.properties[pname])
elif ptype == 'table':
self.assertEquals({'foo': 'bar'}, frame.properties[pname])
assert_equals(4, frame.channel_id)
assert_equals(5, frame._class_id)
assert_equals(6, frame._weight)
assert_equals(7, frame._size)
def test_parse_for_standard_properties(self):
bit_writer = Writer()
val_writer = Writer()
stream = StringIO()
# strip ms because amqp doesn't include it
now = datetime.fromtimestamp( long(time.mktime(datetime.now().timetuple())) )
bit_field = 0
for pname, ptype, reader, writer in HeaderFrame.PROPERTIES:
bit_field = (bit_field << 1) | 1
if ptype=='shortstr':
val_writer.write_shortstr( pname )
elif ptype=='octet':
val_writer.write_octet( 42 )
elif ptype=='timestamp':
val_writer.write_timestamp( now )
elif ptype=='table':
val_writer.write_table( {'foo':'bar'} )
bit_field <<= (16- len(HeaderFrame.PROPERTIES))
bit_writer.write_short( bit_field )
payload = struct.pack( '>HHQ', 5, 6, 7 )
payload += bit_writer.buffer()
payload += val_writer.buffer()
reader = Reader(payload)
frame = HeaderFrame.parse(4, reader)
for pname, ptype, reader, writer in HeaderFrame.PROPERTIES:
if ptype=='shortstr':
self.assertEquals( pname, frame.properties[pname] )
elif ptype=='octet':
self.assertEquals( 42, frame.properties[pname] )
elif ptype=='timestamp':
self.assertEquals( now, frame.properties[pname] )
elif ptype=='table':
self.assertEquals( {'foo':'bar'}, frame.properties[pname] )
def __init__(self, **kwargs):
'''
Initialize the connection.
'''
self._debug = kwargs.get('debug', False)
self._logger = kwargs.get('logger', root_logger)
self._user = kwargs.get('user', 'guest')
self._password = kwargs.get('password', 'guest')
self._host = kwargs.get('host', 'localhost')
self._port = kwargs.get('port', 5672)
self._vhost = kwargs.get('vhost', '/')
self._connect_timeout = kwargs.get('connect_timeout', 5)
self._sock_opts = kwargs.get('sock_opts')
self._sock = None
self._heartbeat = kwargs.get('heartbeat')
self._open_cb = kwargs.get('open_cb')
self._close_cb = kwargs.get('close_cb')
self._login_method = kwargs.get('login_method', 'AMQPLAIN')
self._locale = kwargs.get('locale', 'en_US')
self._client_properties = kwargs.get('client_properties')
self._properties = LIBRARY_PROPERTIES.copy()
if self._client_properties:
self._properties.update(self._client_properties)
self._closed = False
self._connected = False
self._close_info = {
'reply_code': 0,
'reply_text': 'first connect',
'class_id': 0,
'method_id': 0
}
# Not sure what's better here, setdefaults or require the caller to pass
# the whole thing in.
self._class_map = kwargs.get('class_map', {}).copy()
self._class_map.setdefault(20, ChannelClass)
self._class_map.setdefault(40, ExchangeClass)
self._class_map.setdefault(50, QueueClass)
self._class_map.setdefault(60, BasicClass)
self._class_map.setdefault(90, TransactionClass)
self._channels = {0: ConnectionChannel(self, 0, {})}
# Login response seems a total hack of protocol
# Skip the length at the beginning
login_response = Writer()
login_response.write_table({
'LOGIN': self._user,
'PASSWORD': self._password
})
self._login_response = login_response.buffer()[4:]
self._channel_counter = 0
self._channel_max = 65535
self._frame_max = 65535
self._frames_read = 0
self._frames_written = 0
# Default to the socket strategy
transport = kwargs.get('transport', 'socket')
if not isinstance(transport, Transport):
if transport == 'event':
from haigha.transports.event_transport import EventTransport
self._transport = EventTransport(self)
elif transport == 'gevent':
from haigha.transports.gevent_transport import GeventTransport
self._transport = GeventTransport(self)
elif transport == 'gevent_pool':
from haigha.transports.gevent_transport import GeventPoolTransport
self._transport = GeventPoolTransport(self)
elif transport == 'socket':
from haigha.transports.socket_transport import SocketTransport
self._transport = SocketTransport(self)
else:
self._transport = transport
self._output_frame_buffer = []
self.connect(self._host, self._port)
def __init__(self, **kwargs):
'''
Initialize the connection.
'''
self._debug = kwargs.get('debug', False)
self._logger = kwargs.get('logger', logging.root)
self._user = kwargs.get('user', 'guest')
self._password = kwargs.get('password', 'guest')
self._host = kwargs.get('host', 'localhost')
self._port = kwargs.get('port', 5672)
self._vhost = kwargs.get('vhost', '/')
self._connect_timeout = kwargs.get('connect_timeout', 5)
self._sock_opts = kwargs.get('sock_opts')
self._sock = None
self._heartbeat = kwargs.get('heartbeat')
self._open_cb = kwargs.get('open_cb')
self._close_cb = kwargs.get('close_cb')
self._login_method = kwargs.get('login_method', 'AMQPLAIN')
self._locale = kwargs.get('locale', 'en_US')
self._client_properties = kwargs.get('client_properties')
self._properties = LIBRARY_PROPERTIES.copy()
if self._client_properties:
self._properties.update(self._client_properties)
self._closed = False
self._connected = False
self._close_info = {
'reply_code': 0,
'reply_text': 'first connect',
'class_id': 0,
'method_id': 0
}
# Not sure what's better here, setdefaults or require the caller to pass
# the whole thing in.
self._class_map = kwargs.get('class_map', {}).copy()
self._class_map.setdefault(20, ChannelClass)
self._class_map.setdefault(40, ExchangeClass)
self._class_map.setdefault(50, QueueClass)
self._class_map.setdefault(60, BasicClass)
self._class_map.setdefault(90, TransactionClass)
self._channels = {
0: ConnectionChannel(self, 0, {})
}
# Login response seems a total hack of protocol
# Skip the length at the beginning
login_response = Writer()
login_response.write_table({'LOGIN': self._user,
'PASSWORD': self._password})
self._login_response = login_response.buffer()[4:]
self._channel_counter = 0
self._channel_max = USHORT_MAX
self._frame_max = USHORT_MAX
self._frames_read = 0
self._frames_written = 0
# Default to the socket strategy
transport = kwargs.get('transport', 'socket')
if not isinstance(transport, Transport):
if transport == 'event':
from haigha.transports.event_transport import EventTransport
self._transport = EventTransport(self)
elif transport == 'gevent':
from haigha.transports.gevent_transport import GeventTransport
self._transport = GeventTransport(self)
elif transport == 'gevent_pool':
from haigha.transports.gevent_transport import GeventPoolTransport
self._transport = GeventPoolTransport(self)
elif transport == 'socket':
from haigha.transports.socket_transport import SocketTransport
self._transport = SocketTransport(self)
else:
self._transport = transport
# Set these after the transport is initialized, so that we can access the
# synchronous property
self._synchronous = kwargs.get('synchronous', False)
self._synchronous_connect = \
kwargs.get('synchronous_connect', False) or self.synchronous
self._output_frame_buffer = []
self.connect(self._host, self._port)
def __init__(self, **kwargs):
'''
Initialize the connection.
'''
self._debug = kwargs.get('debug', False)
self._logger = kwargs.get('logger', root_logger)
self._user = kwargs.get('user', 'guest')
self._password = kwargs.get('password', 'guest')
self._host = kwargs.get('host', 'localhost')
self._vhost = kwargs.get('vhost', '/')
self._connect_timeout = kwargs.get('connect_timeout', 5)
self._sock_opts = kwargs.get('sock_opts')
self._sock = None
self._heartbeat = kwargs.get('heartbeat')
self._reconnect_cb = kwargs.get('reconnect_cb')
self._close_cb = kwargs.get('close_cb')
self._login_method = kwargs.get('login_method', 'AMQPLAIN')
self._locale = kwargs.get('locale', 'en_US')
self._client_properties = kwargs.get('client_properties')
self._properties = LIBRARY_PROPERTIES.copy()
if self._client_properties:
self._properties.update( self._client_properties )
self._closed = False
self._connected = False
self._close_info = {
'reply_code' : 0,
'reply_text' : 'first connect',
'class_id' : 0,
'method_id' : 0
}
self._channels = {
0 : ConnectionChannel(self, 0)
}
login_response = Writer()
login_response.write_table({'LOGIN': self._user, 'PASSWORD': self._password})
#stream = BytesIO()
#login_response.flush(stream)
#self._login_response = stream.getvalue()[4:] #Skip the length
#at the beginning
self._login_response = login_response.buffer()[4:]
self._channel_counter = 0
self._channel_max = 65535
self._frame_max = 65535
self._frames_read = 0
self._frames_written = 0
self._strategy = kwargs.get('connection_strategy')
if not self._strategy:
self._strategy = ConnectionStrategy( self, self._host, reconnect_cb = self._reconnect_cb )
self._strategy.connect()
self._output_frame_buffer = []
def __init__(self, **kwargs):
'''
Initialize the connection.
'''
self._debug = kwargs.get('debug', False)
self._logger = kwargs.get('logger', root_logger)
self._user = kwargs.get('user', 'guest')
self._password = kwargs.get('password', 'guest')
self._host = kwargs.get('host', 'localhost')
self._vhost = kwargs.get('vhost', '/')
self._connect_timeout = kwargs.get('connect_timeout', 5)
self._sock_opts = kwargs.get('sock_opts')
self._sock = None
self._heartbeat = kwargs.get('heartbeat')
self._reconnect_cb = kwargs.get('reconnect_cb')
self._close_cb = kwargs.get('close_cb')
self._login_method = kwargs.get('login_method', 'AMQPLAIN')
self._locale = kwargs.get('locale', 'en_US')
self._client_properties = kwargs.get('client_properties')
self._properties = LIBRARY_PROPERTIES.copy()
if self._client_properties:
self._properties.update(self._client_properties)
self._closed = False
self._connected = False
self._close_info = {
'reply_code': 0,
'reply_text': 'first connect',
'class_id': 0,
'method_id': 0
}
self._channels = {0: ConnectionChannel(self, 0)}
login_response = Writer()
login_response.write_table({
'LOGIN': self._user,
'PASSWORD': self._password
})
#stream = BytesIO()
#login_response.flush(stream)
#self._login_response = stream.getvalue()[4:] #Skip the length
#at the beginning
self._login_response = login_response.buffer()[4:]
self._channel_counter = 0
self._channel_max = 65535
self._frame_max = 65535
self._frames_read = 0
self._frames_written = 0
self._strategy = kwargs.get('connection_strategy')
if not self._strategy:
self._strategy = ConnectionStrategy(
self, self._host, reconnect_cb=self._reconnect_cb)
self._strategy.connect()
self._output_frame_buffer = []
