def test_response_join():
def _callback(response, ):
assert response.request.command == 'join'
assert not response.error
assert response.body is not None
assert response.seq == 1
_body = response.body
assert isinstance(
_body,
dict,
)
assert 'Num' in _body
assert _body.get('Num') == 1
_body = dict(
Existing=('127.0.0.1:7901', ),
Replay=True,
)
_client = serf.Client(connection_class=JoinFakeConnectionNormal, )
_client.join(**_body).add_callback(_callback, ).request()
_client = serf.Client(connection_class=JoinFakeConnectionMangled, )
_client.join(**_body).add_callback(_callback, ).request()
def test_response_query():
_client = serf.Client(connection_class=QueryFakeConnection, )
def _callback(response, ):
assert response.request.command == 'query'
assert not response.error
assert response.is_success
assert response.body is not None
assert response.seq == 1
assert response.body == QueryFakeConnection.responses[len(_responses)]
_responses.append(response)
return
_body = dict(
FilterNodes=[
"node0",
"node1",
],
FilterTags={"role": ".*"},
RequestAck=True,
Timeout=0,
Name='response-me',
Payload='this is payload of `response-me` query event',
)
_responses = list()
_client.query(**_body).add_callback(_callback, ).watch()
def test_response_query():
_client = serf.Client(connection_class=QueryFakeConnection, )
def _callback(response, ):
assert response.request.command == 'query'
assert not response.error
assert response.is_success
assert response.body is not None
assert response.seq == 1
return
_body = dict(
FilterNodes=[
"node0",
"node1",
],
FilterTags={"role": ".*"},
RequestAck=True,
Timeout=0,
Name='response-me',
Payload='this is payload of `response-me` query event',
)
_responses_all = _client.query(**_body).add_callback(_callback, ).watch()
_responses = list()
for i in _responses_all:
if i.request.command not in ('query', ):
continue
_responses.append(i, )
for _n, i in enumerate(QueryFakeConnection.responses):
assert _responses[_n].body == i
def test_response_stream_stop_receive_data():
_client = serf.Client(connection_class=StreamFakeConnection, )
_responses = list()
def _callback(response, ):
assert response.request.command == 'stream'
assert not response.error
assert response.is_success
assert response.body is not None
assert response.seq == 1
assert response.body.get('LTime') in StreamFakeConnection.events
if response.body.get('LTime') in (7, ):
raise _exceptions.StopReceiveData
_responses.append(response, )
return
_body = dict(Type='*', )
_client.stream(**_body).add_callback(_callback, ).watch()
assert len(_responses) == 2
_event_ids = StreamFakeConnection.events.keys()
_event_ids.sort()
for _n, i in enumerate(_event_ids[:len(_responses)]):
assert _responses[_n].body == StreamFakeConnection.events[i]
return
def test_support_context_manager () :
_client = serf.Client(connection_class=HandshakeFakeConnection, )
with _client :
assert not _client._conn.disconnected
_client.handshake()
_client.request()
assert _client._conn.disconnected
def test_fake_connection():
_client = serf.Client(connection_class=FakeConnection, )
assert _client._conn.connection is not None
assert not _client._conn.disconnected
assert isinstance(
_client._conn.connection,
FakeSocket,
)
def test_hosts_argument_simple():
_host = (
'192.168.100.1',
7374,
)
_client = serf.Client('%s:%s' % _host, )
assert len(_client._conn._members) == 1
assert _client._conn._members[0][:2] == _host
def test_hosts_argument_with_auth_token():
_host = 'serf://192.168.100.1:7374?AuthKey=this-is-token,serf://192.168.100.2:7373?AuthKey=this-is-another-token'
_client = serf.Client(_host, )
assert 'AuthKey' in _client._conn._members[0][2]
assert _client._conn._members[0][2]['AuthKey'] == 'this-is-token'
assert 'AuthKey' in _client._conn._members[1][2]
assert _client._conn._members[1][2]['AuthKey'] == 'this-is-another-token'
def test_hosts_argument_url_format():
_host = (
'serf',
'192.168.100.1',
7374,
)
_client = serf.Client('%s://%s:%s' % _host, )
assert len(_client._conn._members) == 1
assert _client._conn._members[0][:2] == _host[1:]
def test_default_hosts():
_client = serf.Client()
assert _client._conn._members == [
(
serf.constant.DEFAULT_HOST,
serf.constant.DEFAULT_PORT,
dict(),
),
]
def test_response_handshake():
_client = serf.Client(connection_class=HandshakeFakeConnection, )
def _callback(response, ):
assert response.request.command == 'handshake'
assert not response.error
assert response.is_success
assert response.body is None
assert response.seq == 0
_client.handshake().add_callback(_callback, ).request()
def test_response_members_got_error():
_client = serf.Client(connection_class=MembersFakeConnectionGotError, )
def _callback(response, ):
assert response.request.command == 'members'
assert response.error
assert not response.is_success
assert response.body is None
assert response.seq == 1
_client.members().add_callback(_callback, ).request()
def test_response_force_leave():
_client = serf.Client(connection_class=ForceLeaveFakeConnection, )
def _callback(response, ):
assert response.request.command == 'force_leave'
assert not response.error
assert response.is_success
assert response.body is None
assert response.seq == 1
_body = dict(Node='node0', )
_client.force_leave(**_body).add_callback(_callback, ).request()
def del_tag(self, tag_names_list):
resp = None
try:
client = serf.Client("%s:%d" % (self.rpc_address, self.rpc_port))
client.connect()
client.tags(DeleteTags=tag_names_list)
resp = client.request()
client.disconnect()
except serf._exceptions.ConnectionError:
print "Connection error"
return resp
def test_got_error():
def _callback(response, ):
assert response.request.command == 'join'
assert response.error
assert not response.is_success
assert response.body is None
assert response.seq == 1
_body = dict(
Existing=('127.0.0.1:7901', ),
Replay=True,
)
_client = serf.Client(connection_class=JoinFakeConnectionGotError, )
_client.join(**_body).add_callback(_callback, ).request()
def test_response_handshake_default_callback():
_client = serf.Client(connection_class=HandshakeFakeConnection, )
assert not _client.is_handshaked
def _callback(response, ):
assert response.request.command == 'handshake'
assert not response.error
assert response.is_success
assert response.body is None
assert response.seq == 0
_client.handshake().add_callback(_callback, ).force_leave(
Node='unknown-node0', ).request()
assert _client.is_handshaked
def get_members(self):
# Retrieve informations from all the serf memebrs.
# This is done through the RPC members call.
resp = None
try:
client = serf.Client("%s:%d" % (self.rpc_address, self.rpc_port))
client.connect()
client.members()
resp = client.request(timeout=5)
client.disconnect()
except serf._exceptions.ConnectionError:
print "Connection error"
return resp
def test_response_handshake_and_auth():
_auth_key = uuid.uuid1().hex
_host = 'serf://127.0.0.1:7373?AuthKey=%s' % _auth_key
_client = serf.Client(
_host,
connection_class=HandshakeFakeConnection,
)
def _callback(response, ):
assert response.request.command == 'handshake'
assert not response.error
assert response.is_success
assert response.body is None
assert response.seq == 0
_client.handshake().add_callback(_callback, ).request()
def test_response_auth_success():
_client = serf.Client(connection_class=AuthFakeConnectionSuccess, )
def _callback(response, ):
assert response.request.command == 'auth'
assert not response.error
assert response.is_success
assert response.body is None
assert response.seq == 1
_body = dict(AuthKey='this-is-valid-authkey', )
assert not _client.is_authed
_client.auth(**_body).add_callback(_callback, ).request()
assert _client.is_authed
def test_response_event () :
_client = serf.Client(connection_class=EventFakeConnection, )
def _callback (response, ) :
assert response.request.command == 'event'
assert not response.error
assert response.is_success
assert response.body is None
assert response.seq == 1
_body = dict(
Name='anonymous-event',
Payload='payload',
)
_client.event(**_body).add_callback(_callback, ).request()
def test_response_query_invalid_ack():
_client = serf.Client(connection_class=QueryFakeConnectionInvalidAck, )
_body = dict(
RequestAck=True,
Timeout=0,
Name='response-me',
Payload='this is payload of `response-me` query event',
)
_responses_all = _client.query(**_body).watch()
for i in _responses_all:
if i.request.command not in ('query', ):
continue
if i.body.get('Type', ) in ('ack', ):
assert i.body.get('From', ) != 'node0'
def test_response_auth_failed():
_client = serf.Client(connection_class=AuthFakeConnectionFailed, )
def _callback(response, ):
assert response.request.command == 'auth'
assert response.error
assert not response.is_success
assert response.body is None
assert response.seq == 1
_body = dict(AuthKey='this-is-bad-authkey', )
assert not _client.is_authed
with pytest.raises(serf.AuthenticationError, ):
_client.auth(**_body).add_callback(_callback, ).request()
assert not _client.is_authed
def test_hosts_argument_missing_port():
_hosts_parsed = [
('127.0.0.1', ),
('192.168.0.22', ),
]
_hosts = ','.join(
map(
lambda x: ':'.join(map(
str,
x,
), ),
_hosts_parsed,
), )
_client = serf.Client(hosts=_hosts, )
for n, i in enumerate(_client._conn._members, ):
assert i[0] == _hosts_parsed[n][0]
assert i[1] == serf.constant.DEFAULT_PORT
def test_response_members():
_client = serf.Client(connection_class=MembersFakeConnection, )
def _callback(response, ):
assert response.request.command == 'members'
assert not response.error
assert response.is_success
assert response.body is not None
assert response.seq == 1
_members = response.body.get('Members', )
assert 'Members' in response.body
assert len(_members, ) == 2
# Addr
assert _members[0].get('Addr') == [127, 0, 0, 1]
assert _members[1].get('Addr') == [127, 0, 0, 1]
# Name
assert _members[0].get('Name') == 'node0'
assert _members[1].get('Name') == 'node1'
# Port
assert _members[0].get('Port') == 7900
assert _members[1].get('Port') == 7901
# Tags
assert isinstance(
_members[0].get('Tags'),
dict,
)
assert isinstance(
_members[1].get('Tags'),
dict,
)
assert _members[0].get('Tags') == {'role': 'test-server'}
# Status
assert _members[0].get('Status') == 'alive'
assert _members[1].get('Status') == 'leaving'
_client.members().add_callback(_callback, ).request()
def test_response_monitor():
_client = serf.Client(connection_class=MonitorFakeConnection, )
logs = list(MonitorFakeConnection.logs[:], )
def _callback(response, ):
assert response.request.command == 'monitor'
assert not response.error
assert response.is_success
assert response.body is not None
assert response.seq == 1
_log = response.body
_log_received = logs.pop(0, )
assert _log == _log_received
_body = dict(LogLevel='DEBUG', )
_client.monitor(**_body).add_callback(_callback, ).watch()
def test_response_auth_failed():
"""
when the body first received.
"""
_client = serf.Client(connection_class=FakeConnectionAbnormal, )
def _callback(response, ):
assert response.request.command == 'event'
assert not response.error
assert response.is_success
assert response.body is None
assert response.seq == 1
_body = dict(
Name='anonymous-event',
Payload='payload',
)
_client.event(**_body).add_callback(_callback, ).request()
def test_implicit_authentication_with_host_url_success():
def _callback(response, ):
assert response.request.command == 'force_leave'
assert not response.error
assert response.is_success
assert response.body is None
assert response.seq == 2
_body = dict(Node='node0', )
_auth_key = 'this-is-valid-authkey'
_client = serf.Client(
'serf://127.0.0.1:7373?AuthKey=%s' % _auth_key,
connection_class=AuthFakeConnectionForceLeaveSuccess,
)
assert not _client.is_authed
_client.force_leave(**_body).add_callback(_callback, ).request()
assert _client.is_authed
def listen_for_member_update_events(self, ch_dbfile):
print "Database file: %s" % (ch_dbfile, )
members_updated = False
while True:
# Write the db file based on the current members channels tags
sleep_time = 5
self.client = serf.Client("%s:%d" %
(self.rpc_address, self.rpc_port),
auto_reconnect=True)
while not members_updated:
try:
self.client.connect()
self.ch_dbfile = ch_dbfile
if self.update_db_from_members():
members_updated = True
else:
time.sleep(sleep_time)
except serf._exceptions.ConnectionError:
print "Client connection error (sleep %d)" % (sleep_time, )
time.sleep(sleep_time)
try:
# Register callback for memebr update events
# Todo: handle sigint
self.client.stream(Type="member-update").add_callback(
self.member_update_event_callback).request(timeout=120)
self.client.disconnect()
members_updated = False
except serf._exceptions.ConnectionError:
print "Client connection error (sleep %d)" % (sleep_time, )
time.sleep(sleep_time)
except KeyboardInterrupt:
print "Disconnection from RPC deamon"
self.client.disconnect()
return
def test_hosts_argument():
_hosts_parsed = [
(
'127.0.0.1',
7373,
),
(
'192.168.0.22',
7300,
),
]
_hosts = ','.join(
map(
lambda x: ':'.join(map(
str,
x,
), ),
_hosts_parsed,
), )
_client = serf.Client(hosts=_hosts, )
assert map(lambda x: x[:2], _client._conn._members) == _hosts_parsed
def test_response_stream():
_client = serf.Client(connection_class=StreamFakeConnection, )
def _callback(response, ):
assert response.request.command == 'stream'
assert not response.error
assert response.is_success
assert response.body is not None
assert response.seq == 1
assert response.body.get('LTime') in StreamFakeConnection.events
_event_received = response.body
_event_sent = StreamFakeConnection.events.get(
_event_received.get('LTime'), )
assert _event_sent.get('Name') == _event_received.get('Name')
assert _event_sent.get('Payload') == _event_received.get('Payload')
assert _event_sent.get('Event') == _event_received.get('Event')
_body = dict(Type='*', )
_client.stream(**_body).add_callback(_callback, ).watch()
