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)