class Server:
def __init__(self):
setupLogger()
# Create a TCP socket
self.s = socket(AF_INET, SOCK_STREAM)
# bind it to the server port
self.s.bind((HOSTNAME, int(PORT)))
# Configure it to accept up to N simultaneous Clients waiting...
self.s.listen(MAXCONN)
self.handler = RequestHandler()
self.handler.initialize()
def run(self):
# wait for a connection
waitForRequest = True
while waitForRequest:
try:
print "Starting to receive"
(clientSocket, address) = self.s.accept()
# as soon as we receive a connection from a client, ask a request handler to handle the request
print "Received request"
self.handler.handleRequest(clientSocket)
print "Finished the request Handling"
except KeyboardInterrupt,e:
print "Received shutdown command - shutting down"
break
print "Simulator going down"
def __init__(self):
self.init_node_circle()
self.init_receiver_thread()
self.sender = Sender(self.socket, self.node_circle)
self.kv_store = KVStore()
self.request_handler = RequestHandler(self.sender, self.kv_store, self.node_circle)
self.init_data_migration_thread()
self.init_node_monitor_thread()
self.send_join_request()
self.main_loop()
def __init__(self, ip, isMaster=False):
self.ip = ip
self.port = MEMBERSHIPPORT
self.sdfsSock = TCPSocket()
if (isMaster != False):
self.isMaster = True
else:
self.isMaster = False
self.memberHandler = Membership(ip,
MEMBERSHIPPORT,
isIntroducer=isMaster)
self.memberList = self.memberHandler.memberList
self.memberListLock = self.memberHandler.memberListLock
self.selfInfo = MemberInfo(self.memberHandler.id,
self.memberHandler.ip,
self.memberHandler.port)
self.masterList = {}
self.masterListLock = threading.RLock()
self.masterElection = MasterElection(self.memberList)
self.cloudFiles = {}
self.versionFile = {}
self.metadata = {
} # A dict which stores <filename>: [list of Nodes storing the file]
self.requestHandler = RequestHandler(self.metadata, self.sdfsSock,
self.ip, REQUESTHANDLERPORT,
self.memberList,
self.memberListLock,
self.selfInfo, self.cloudFiles,
self.versionFile)
def https_communication(self, socket):
data = socket.recv(int(self.settings['buff_size']))
keep_connection, replay = RequestHandler.handle_request(data)
socket.send(replay)
if not keep_connection:
self.open_https_sockets.remove(socket)
socket.close()
return
def __init__(self):
setupLogger()
# Create a TCP socket
self.s = socket(AF_INET, SOCK_STREAM)
# bind it to the server port
self.s.bind((HOSTNAME, int(PORT)))
# Configure it to accept up to N simultaneous Clients waiting...
self.s.listen(MAXCONN)
self.handler = RequestHandler()
self.handler.initialize()
def __init__(self):
self.stage = 1
config_reader = ConfigReader.ReadConfig()
config = config_reader.read()
if config.has_section('api_config'):
api_config = dict(config.items('api_config', {}))
self.request_handler = RequestHandler.RequestHandler(api_config)
self.play_game()
else:
print 'API config not available. Cannot start the game ...'
def http_communication(self, socket):
print 'Got a request from: ' + socket.getpeername()[0]
has_length = False
content_length = 0
data = socket.recv(int(self.settings['buff_size']))
header_data = data.split('\r\n\r\n')[0]
header_list = header_data.split('\r\n')
for header in header_list:
if header.startswith('Content-Length: '):
content_length = int(header[16:])
has_length = True
good_download = True
old_data_size = 0
while len(data) - len(header_data + '\r\n\r\n') < content_length and has_length:
data_size = len(data)
request_size = len(header_data + '\r\n\r\n') + content_length
percents = (float(data_size) / float(request_size)) * 100.0
if data_size == old_data_size:
good_download = False
break
old_data_size = data_size
print 'Got %d out of %d/ %d' % (data_size, request_size, percents) + '%'
data += socket.recv(int(self.settings['buff_size']))
if good_download:
try:
keep_connection, replay = RequestHandler.handle_request(data, socket.getpeername()[0])
except:
keep_connection = False
replay = RequestHandler.header_maker('500', keep_connection=False)
if replay is not None:
socket.send(replay)
else:
print 'The client stopped transferring the file'
socket.send(RequestHandler.header_maker('400', keep_connection=False))
keep_connection = False
if not keep_connection:
self.open_http_sockets.remove(socket)
socket.close()
return
def handle_client_connection(client_connection):
# Handle the connection
body = {'response': 'Connection Accepted'}
client_connection.sendall(json.dumps(body).encode('UTF-8'))
request_handler = RequestHandler.RequestHandlerSwitch()
while True:
data = client_connection.recv(1024)
request_body = json.loads(data)
request_body.update({'client_connection': client_connection})
header = request_body.get('header')
# When the Client wishes to disconnect
if header == 'quit':
body = {'response': 'Connection Terminating'}
client_connection.sendall(json.dumps(body).encode('UTF-8'))
break
client_connection.sendall(
request_handler.handle_request(header=header,
request_body=request_body))
client_connection.close()
def bind_connection(self, number_of_clients):
"""
this function creates the connection between the server and the client
:param number_of_clients: the number of clients to listen for
:return: if binded or not
"""
self.__server_socket.settimeout(8)
client_socket = None
while not client_socket:
try:
print("Try to listen")
self.__server_socket.listen(number_of_clients)
client_socket, address = self.__server_socket.accept()
except KeyboardInterrupt:
self.exit()
self.__server_socket.close()
exit(1)
except socket.error:
client_socket = None
self.__client_socket = client_socket
# -----debug--#
if self.__debug:
if self.__client_socket:
print("established connection with: {0}, "
.format(self.__client_socket))
else:
print("the client socket is set to None")
# ---------------
if client_socket:
# creates a request handler to take care of the clients requests.
self.__new_handler = RequestHandler(self.get_client_socket(),
self.__name,
self.__debug)
return True
else:
return False
sys.exit() # Initialise the signal handler. signal.signal(signal.SIGINT, SigHandler) # Get the command line parameter options. CmdOpts = GetOptions() # Initialise the read parameter validator. ReadParams = SBusClient.ReadParamValidator() # Initialise the write parameter validator. WriteParams = SBusClient.WriteParamValidator() # Handles setting communications parameters. ConnectionHandler = RequestHandler.ConnectionStat(5050, SBusClient.SBus) # Set the current version number for display on the web pages. ConnectionHandler.SetVersionInfo(_VERSION) # Handles reading data. ReadRequestHandler = RequestHandler.ReadData(ReadParams, ConnectionHandler) # Handles writing data. WriteRequestHandler = RequestHandler.WriteData(WriteParams, ConnectionHandler) ############################################################ # Initialise the client. First get the remote host parameters. rhost, rport, rtimeout, runitid, autoreconnect = CmdOpts.GetRemoteParams() # Set the parameters. ConnectionHandler.SetConnectionParams(rhost, rport, rtimeout, runitid,
def handleSubscribedSlackEvents():
Logger.logIncomingRequest(request.headers, request.get_data())
RequestHandler.verifySlackRequest(request)
return EventOperation.handle(request)
def handleSlackCommand():
Logger.logIncomingRequest(request.headers, request.get_data())
RequestHandler.verifySlackRequest(request)
return CommandOperation.handle(request)
class App:
def __init__(self):
self.init_node_circle()
self.init_receiver_thread()
self.sender = Sender(self.socket, self.node_circle)
self.kv_store = KVStore()
self.request_handler = RequestHandler(self.sender, self.kv_store, self.node_circle)
self.init_data_migration_thread()
self.init_node_monitor_thread()
self.send_join_request()
self.main_loop()
def init_node_circle(self):
if len(sys.argv) > 1:
filename = sys.argv[1]
else:
filename = "hosts.txt"
nodes = []
with open(filename) as f:
lines = [x.strip('\n') for x in f.readlines()]
for line in lines:
host, port, location = line.split(":")
node = Node(host, port, location)
nodes.append(node)
self.socket, my_node = self.get_my_socket_and_node(nodes)
self.node_circle = NodeCircle(nodes, my_node)
def get_my_socket_and_node(self, nodes):
nodes_for_my_ip = []
for node in nodes:
ip = node.ip
if self.does_ip_match_mine(ip):
nodes_for_my_ip.append(node)
for node in nodes_for_my_ip:
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind(node.get_addr())
sock.setblocking(True)
print "Connected to " + str(node)
return (sock, node)
except socket.error:
pass
print "Could not find open port, Exiting"
sys.exit()
def does_ip_match_mine(self, ip):
return ip.startswith("127.") or ip.startswith("localhost") or ip == socket.gethostbyname(socket.gethostname()) or ip == socket.gethostname()
def init_receiver_thread(self):
self.received_data_queue = Queue.Queue()
self.receiver_thread = ReceiverThread(self.socket, self.received_data_queue)
self.receiver_thread.start()
def init_data_migration_thread(self):
self.data_migration_thread = DataMigrationThread(self.sender, self.node_circle, self.kv_store, self.received_data_queue)
self.data_migration_thread.start()
def init_node_monitor_thread(self):
self.node_monitor_thread = NodeMonitorThread(self.sender, self.node_circle, self.received_data_queue)
self.node_monitor_thread.start()
def send_join_request(self):
predecessor = self.node_circle.get_my_predecessor()
print "send join " + str(predecessor)
if predecessor:
self.sender.send_request(JoinRequest(), predecessor, onFail=self.send_join_request)
def main_loop(self):
while True:
received_data = self.wait_until_next_event_or_data()
if received_data is not None:
data, sender_address = received_data
else:
data = None
sender_address = None
if self.is_data_valid(data):
self.handle_valid_data(data, sender_address)
self.received_data_queue.task_done()
self.sender.check_for_timeouts()
def is_data_valid(self, data):
return data and len(data) > UID.LENGTH
def handle_valid_data(self, data, sender_address):
uid = UID.from_bytes(data)
payload = data[UID.LENGTH:]
if self.sender.check_cached_responses(uid, sender_address):
return
if self.sender.check_pending_requests(uid, sender_address):
return
request = Request.from_bytes(payload)
if request:
self.handle_request(uid, request, sender_address)
else:
self.sender.send_response(uid, UnrecognizedCommandResponse(), sender_address)
def handle_request(self, uid, request, sender_address):
if not hasattr(request, "key") or self.node_circle.is_my_key(request.key) or Request.is_internal(request):
self.request_handler.handle_request(uid, request, sender_address)
else:
self.forward_request(uid, request, sender_address)
def forward_request(self, uid, original_request, sender_address):
dest_node = self.node_circle.get_optimal_node_for_key(original_request.key)
request = ForwardedRequest(uid, sender_address, original_request)
self.sender.send_request(request, dest_node)
def wait_until_next_event_or_data(self):
try:
return self.received_data_queue.get(timeout=self.get_time_til_next_event())
except Queue.Empty:
return (None, None)
def get_time_til_next_event(self):
return self.sender.get_time_til_next_timeout()
form = cgi.FieldStorage()
range_query = 'from' in form and 'to' in form
last_query = 'last' in form
if not range_query and not last_query:
print('Content-type: text/html\n')
print('<title>Reply Page</title>')
print('<h1>select from and to range or last(hour,day)</h1>')
else:
try:
import DatabaseConfig
if range_query:
fromTime = parseDateTimeString(form['from'].value, True)
toTime = parseDateTimeString(form['to'].value, False)
else:
toTime = datetime.datetime.now()
dt = datetime.timedelta(days=1) if form['last'] == 'hour' else datetime.timedelta(hours=1)
fromTime = toTime - dt
data = DatabaseConfig.db.getValues(fromTime, toTime)
plot = RequestHandler.formatToPlot(data)
print('Content-type: image/png\n')
sys.stdout.buffer.write(plot)
except Exception as e:
print('Content-type: text/html\n')
print(e)
