def _connect(self, index):
try:
sock = self._server_socks[index]
server_hostport = self._server_hostports[index]
sock.connect(utils.address(server_hostport))
utils.send(sock, self._identifier, 0, 'server')
identifier, number, _, state = utils.recv(sock)
# make sure server is still connected
if identifier is None:
sock.close()
self._server_socks[index] = socket.socket()
self._connected[index] = False
else:
self._print(f'Connected to Server {identifier}')
# update state
if number > self._num_requests:
with self._lock:
self._print('Updating state')
self._state = state
self._num_requests = number
if self._log:
self._print('Clearing log')
for request in self._log:
self._state.update(int(request))
self._log = []
self._ready = True
self._ready = True
self._connected[index] = True
except Exception:
self._connected[index] = False
def _heartbeat(self):
# connect to server
connected, server_identifier = self._connect()
# connect to gfd
self._print(f'Connecting to GFD at {self._gfd_hostport}')
self._gfd_sock.connect(utils.address(self._gfd_hostport))
utils.send(self._gfd_sock, self._identifier, 0, 'lfd')
gfd_identifier, _, _, _ = utils.recv(self._gfd_sock)
# make sure gfd is still connected
if gfd_identifier is None:
self._gfd_sock.close()
self._gfd_sock = socket.socket()
self._print('Connection closed by GFD at ' f'{self._gfd_hostport}')
return
self._print(f'Connected to GFD {gfd_identifier}')
member = False
number = 1
while True:
if not connected:
connected, server_identifier = self._connect()
if connected:
self._print(f'Sending heartbeat #{number} to Server '
f'{server_identifier}')
utils.send(self._server_sock, self._identifier, number,
'heartbeat')
_, res_number, response, _ = utils.recv(self._server_sock)
if response is None:
self._print(f'No response from Server {server_identifier}')
self._server_sock.close()
self._server_sock = socket.socket()
connected = False
if member:
self._print(f'Alerting GFD')
utils.send(self._gfd_sock, self._identifier, 0,
'remove')
member = False
else:
self._print(
f'Heartbeat response #{res_number} from Server '
f'{server_identifier}')
if not member:
self._print(f'Registering membership with GFD')
utils.send(self._gfd_sock, self._identifier, 0, 'add')
member = True
number += 1
time.sleep(self._interval)
def _connect(self):
try:
self._print(f'Connecting to server at {self._server_hostport}')
self._server_sock.connect(utils.address(self._server_hostport))
utils.send(self._server_sock, self._identifier, 0, 'lfd')
server_identifier, _, _, _ = utils.recv(self._server_sock)
# make sure server is still connected
if server_identifier is None:
self._server_sock.close()
self._server_sock = socket.socket()
self._print('Connection closed by server at '
f'{self._server_hostport}')
return False, server_identifier
self._print(f'Connected to Server {server_identifier}')
return True, server_identifier
except Exception:
return False, None
def _connect(self):
try:
self._print(f'Connecting to RM at {self._rm_hostport}')
self._rm_sock.connect(utils.address(self._rm_hostport))
utils.send(self._rm_sock, self._identifier, 0, 'gfd')
rm_identifier, _, _, _ = utils.recv(self._rm_sock)
# make sure rm is still connected
if rm_identifier is None:
self._rm_sock.close()
self._rm_sock = socket.socket()
self._print('Connection closed by RM at '
f'{self._rm_hostport}')
self._rm_connected = False
self._print(f'Connected to RM {rm_identifier}')
self._rm_connected = True
except Exception:
self._rm_connected = False
def __init__(self, identifier, port, verbose=True):
self._stdout = sys.stdout
if not verbose:
dev_null = open(os.devnull, 'w')
self._stdout = dev_null
# rm info
self._identifier = identifier
self._hostport = socket.gethostname() + ':' + str(port)
# bind socket
sock = socket.socket()
sock.bind(utils.address(self._hostport))
self._sock = sock
# membership
self._members = []
# rm process
self._process = None
def __init__(self, identifier, port, rm_hostport, verbose=True):
self._stdout = sys.stdout
if not verbose:
dev_null = open(os.devnull, 'w')
self._stdout = dev_null
# gfd info
self._identifier = identifier
self._hostport = socket.gethostname() + ':' + str(port)
self._rm_hostport = rm_hostport
# create sockets
self._sock = socket.socket()
self._sock.bind(utils.address(self._hostport))
self._rm_sock = socket.socket()
self._rm_connected = False
# membership
self._members = []
# gfd process
self._process = None
def __init__(self,
identifier,
port,
server_hostports,
interval,
active=False,
verbose=True):
self._stdout = sys.stdout
if not verbose:
dev_null = open(os.devnull, 'w')
self._stdout = dev_null
# server info
self._identifier = identifier
self._hostport = socket.gethostname() + ':' + str(port)
self._server_hostports = server_hostports
self._interval = interval
self._active = active
self._primary = False
self._primary_index = None
# bind sockets
self._sock = socket.socket()
self._sock.bind(utils.address(self._hostport))
self._server_socks = [socket.socket() for hostport in server_hostports]
self._connected = [False for hostport in server_hostports]
# server state
self._state = ServerState()
self._log = []
self._num_requests = 0
self._ready = False
self._lock = Lock()
# server process
self._process = None