def ProxyClientCommand(sock, server_addr, server_port, cache, max_age_in_sec): """Receives a command from a client and forwards it to a server:port. A single command is read from `sock`. That command is passed to the specified `server`:`port`. The response from the server is then passed back through `sock`. Args: sock: A TCP socket that connects to the client. server_addr: A string with the name of the server to forward requests to. server_port: An int from 0 to 2^16 with the port the server is listening on. cache: A KeyValueStore object that maintains a temorary cache. max_age_in_sec: float. Cached values older than this are re-retrieved from the server. """ command_line = library.ReadCommand(sock) # obtain command from user command, _, _ = library.ParseCommand(command_line) if command == "GET" or command == "get": # if command involves cache cached_result = cache.GetValue(command_line, max_age_in_sec) if cached_result is not None: # if command was previously utilized print("Cache utilized") result = cached_result else: result = ForwardCommandToServer(command_line, server_addr, server_port) cache.StoreValue(command_line, result) # cache result for future use else: result = ForwardCommandToServer(command_line, server_addr, server_port) MirrorMessage(sock, result) # output message to client
def ProxyClientCommand(sock, server_addr, server_port, cache): """Receives a command from a client and forwards it to a server:port. A single command is read from `sock`. That command is passed to the specified `server`:`port`. The response from the server is then passed back through `sock`. Args: sock: A TCP socket that connects to the client. server_addr: A string with the name of the server to forward requests to. server_port: An int from 0 to 2^16 with the port the server is listening on. cache: A KeyValueStore object that maintains a temporary cache. max_age_in_sec: float. Cached values older than this are re-retrieved from the server. """ command = library.ReadCommand(sock) result = CheckCachedResponse(command, cache) if result: if result[1]: msg = result[1] else: msg = ForwardCommandToServer(command, server_addr, server_port) if msg != "Not Found.": cache.StoreValue(result[0], msg) else: msg = ForwardCommandToServer(command, server_addr, server_port) sock.send('%s\n' % msg)
def ProxyClientCommand(client_sock, server_addr, server_port, cache): """Receives a command from a client and forwards it to a server:port. A single command is read from `sock`. That command is passed to the specified `server`:`port`. The response from the server is then passed back through `sock`. Args: sock: A TCP socket that connects to the client. server_addr: A string with the name of the server to forward requests to. server_port: An int from 0 to 2^16 with the port the server is listening on. cache: A KeyValueStore object that maintains a temorary cache. max_age_in_sec: float. Cached values older than this are re-retrieved from the server. """ ########################################### #TODO: Implement ProxyClientCommand ########################################### command_line = library.ReadCommand(client_sock) response = CheckCachedResponse(command_line, cache) cmd, name, text = library.ParseCommand(command_line) if not response: # If there is no response from the proxy, go to main server else get response from cache response = ForwardCommandToServer(command_line, server_addr, server_port) if cmd == "GET": # Only on the GET commands do we store the value in the cache if there was no response from the proxy cache.StoreValue(name, response) client_sock.sendall('%s\n' % response)
def ProxyClientCommand(sock, server_addr, server_port, cache): """Receives a command from a client and forwards it to a server:port. A single command is read from `sock`. That command is passed to the specified `server`:`port`. The response from the server is then passed back through `sock`. Args: sock: A TCP socket that connects to the client. server_addr: A string with the name of the server to forward requests to. server_port: An int from 0 to 2^16 with the port the server is listening on. cache: A KeyValueStore object that maintains a temorary cache. max_age_in_sec: float. Cached values older than this are re-retrieved from the server. """ command_line = library.ReadCommand(sock) cmd, name, text = library.ParseCommand(command_line) result = '' # Update the cache for PUT commands but also pass the traffic to the server. # GET commands can be cached. msg_to_server = (command_line, server_addr, server_port) if cmd == 'PUT': result = PutCommand(name, text, cache, msg_to_server) elif cmd == 'GET': result = GetCommand(name, cache, msg_to_server) elif cmd == 'DUMP': result = DumpCommand(msg_to_server) else: result = f'Unknown command {cmd}' SendText(sock, result)
def main(): # Store all key/value pairs in here. database = library.KeyValueStore() # The server socket that will listen on the specified port. If you don't # have permission to listen on the port, try a higher numbered port. server_sock = library.CreateServerSocket(LISTENING_PORT) # Handle commands indefinitely. Use ^C to exit the program. while True: # Wait until a client connects and then get a socket that connects to the # client. client_sock, (address, port) = library.ConnectClientToServer(server_sock) print('Received connection from %s:%d' % (address, port)) # Read a command. command_line = library.ReadCommand(client_sock) command, name, text = library.ParseCommand(command_line) # Execute the command based on the first word in the command line. if command == 'PUT': result = PutCommand(name, text, database) elif command == 'GET': result = GetCommand(name, database) elif command == 'DUMP': result = DumpCommand(database) else: result = 'Unknown command %s' % command SendText(client_sock, result) client_sock.close()
def main(): # Store all key/value pairs in here. database = library.KeyValueStore() # The server socket that will listen on the specified port. If you don't # have permission to listen on the port, try a higher numbered port. server_sock = library.CreateServerSocket(LISTENING_PORT) # It will now handle it completely. while True: # Wait until a client connects and then get a socket that connects to the # client. client_sock, (address, port) = library.ConnectClientToServer( server_sock, LISTENING_PORT) print('Received connection from %s:%d' % (address, port)) # It now reads the command and executes it. command_line = library.ReadCommand(client_sock) command, name, text = library.ParseCommand(command_line) if command == 'PUT': result = PutCommand(name, text, database) elif command == 'GET': result = GetCommand(name, database) elif command == 'DUMP': result = DumpCommand(database) else: SendText(client_sock, 'Unknown command %s' % command) SendText(client_sock, result) # We're done with the client, so clean up the socket. ################################# client_sock.close()
def ProxyClientCommand(sock, server_addr, server_port, cache): """Receives a command from a client and forwards it to a server:port. A single command is read from `sock`. That command is passed to the specified `server`:`port`. The response from the server is then passed back through `sock`. Args: sock: A TCP socket that connects to the client. server_addr: A string with the name of the server to forward requests to. server_port: An int from 0 to 2^16 with the port the server is listening on. cache: A KeyValueStore object that maintains a temorary cache. max_age_in_sec: float. Cached values older than this are re-retrieved from the server. """ command_line = library.ReadCommand(sock) cmd, name, text = library.ParseCommand(command_line) response = ForwardCommandToServer(command_line,server_addr,server_port) checkedResponse = CheckCachedResponse(command_line, cache): if checkedResponse == None: sock.send(response) else: sock.send(checkedResponse)
def ForwardCommandToServer(command, server_addr, server_port): client_socket = library.CreateClientSocket(server_addr, server_port) client_socket.send(command + '\n') server_response = library.ReadCommand(client_socket) client_socket.close() return server_response + '\n'
def ForwardCommandToServer(command, server_addr, server_port): s = library.CreateClientSocket(server_addr,server_port) s.sendall(command) data = library.ReadCommand(s) data=data.strip('/n') s.close() return data """Opens a TCP socket to the server, sends a command, and returns response.
def main(records_file=None): # Store all key/value pairs in here. if records_file: try: database = library.KeyValueStore(fileName=records_file) except library.InvalidRecordFormatException as e: print(e) print("Initializing an empty database") database = library.KeyValueStore() except library.InvalidRecordTypeException as e: print(e) print("Initializing an empty database") database = library.KeyValueStore() else: database = library.KeyValueStore() # The server socket that will listen on the specified port. If you don't # have permission to listen on the port, try a higher numbered port. server_sock = library.CreateServerSocket(LISTENING_PORT) # Handle commands indefinitely. Use ^C to exit the program. try: while True: # Wait until a client connects and then get a socket that connects to the # client. client_sock, (address, port) = library.ConnectClientToServer(server_sock) print('Received connection from %s:%d' % (address, port)) # Read a command. command_line = library.ReadCommand(client_sock) command, name, text = library.ParseCommand(command_line) # Execute the command based on the first word in the command line. if command == 'PUT': result = PutCommand(name, text, database) elif command == 'GET': result = GetCommand(name, database) elif command == 'DUMP': result = DumpCommand(database) else: SendText(client_sock, 'Unknown command %s' % command) SendText(client_sock, result) # We're done with the client, so clean up the socket. client_sock.close() except KeyboardInterrupt: # Write records to a file, which can be restored later. # Close the server socket. server_sock.close() with open("server-records.txt", 'w') as fileHandle: fileHandle.write(str(database))
def ForwardCommandToServer(command, server_addr, server_port): """Opens a TCP socket to the server, sends a command, and returns response. Args: command: A single line string command with no newlines in it. server_addr: A string with the name of the server to forward requests to. server_port: An int from 0 to 2^16 with the port the server is listening on. Returns: A single line string response with no newlines. """ sock = library.CreateClientSocket(server_addr, server_port) sock.send('%s\n' % command) result = library.ReadCommand(sock) sock.close() return result.strip('\n')
def ForwardCommandToServer(command, server_addr, server_port): """Opens a TCP socket to the server, sends a command, and returns response. Args: command: A single line string command with no newlines in it. server_addr: A string with the name of the server to forward requests to. server_port: An int from 0 to 2^16 with the port the server is listening on. Returns: A single line string response with no newlines. """ socket = library.CreateClientSocket(server_addr, server_port) socket.send(command) # Wait to receive the data from the server socket. return library.ReadCommand(socket)
def ForwardCommandToServer(command, server_addr, server_port): # """Opens a TCP socket to the server, sends a command, and returns response. # # Args: # command: A single line string command with no newlines in it. # server_addr: A string with the name of the server to forward requests to. # server_port: An int from 0 to 2^16 with the port the server is listening on. # Returns: # A single line string response with no newlines. # """ ################################################### Socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) Socket.connect((server_addr, server_port)) Socket.send(command) return library.ReadCommand(Socket)
def ProxyClientCommand(sock, server_addr, server_port, cache): command_line = library.ReadCommand(sock) cmd, name, value = library.ParseCommand(command_line) if cmd == 'PUT': server_response = ForwardCommandToServer(command_line, server_addr, server_port) cache.StoreValue(name, server_response) elif (cmd == 'GET'): server_response = cache.GetValue(name) if server_response == None: server_response = ForwardCommandToServer(command_line, server_addr, server_port) else: server_response = ForwardCommandToServer(command_line, server_addr, server_port) sock.send(server_response)
def ProxyClientCommand(sock, server_addr, server_port, cache): command_line = library.ReadCommand(sock) command, name, text = library.ParseCommand(command_line) returning_str = "" if (command == "GET"): #if GET, name might be in cache or not if (name in cache.keyvalue): timeElapsed = time.time() - (cache.keyvalue[name])[1] if ( timeElapsed < MAX_CACHE_AGE_SEC ): #No problem with cached information if last cached time is less than 60 seconds. returning_text = (cache.keyvalue[name])[0].decode( ) + " ( Returned from proxy) " SendText(sock, returning_text) else: data = ForwardCommandToServer( command_line, server_addr, server_port ) #If last cached time is more than 60 seconds, pull the info from main server cache.keyvalue[name] = [data, time.time()] sock.send(data + b"\n") else: #if not found in cache, forward to the server. Server will handle KEY NOT FOUND error data = ForwardCommandToServer(command_line, server_addr, server_port) if (ServerFound(data) == True): cache.keyvalue[name] = [ data, time.time() ] #cache the data only if server found the key sock.send(data + b"\n") elif (command == "PUT"): if (name == None or text == None): returning_str = "Key And Value both needed for PUT operation\n" SendText(sock, returning_str) else: returning_str = name + " = " + text ForwardCommandToServer(command_line, server_addr, server_port) SendText(sock, returning_str) elif (command == "DUMP"): #command = "DUMP" data = ForwardCommandToServer(command_line, server_addr, server_port) sock.send(data + b"\n") else: SendText(sock, 'Unknown command %s' % command) return
def ForwardCommandToServer(command, server_addr, server_port): """Opens a TCP socket to the server, sends a command, and returns response. Args: command: A single line string command with no newlines in it. server_addr: A string with the name of the server to forward requests to. server_port: An int from 0 to 2^16 with the port the server is listening on. Returns: A single line string response with no newlines. """ ################################################### #TODO: Implement Function: WiP The_Sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) Socket.connect((server_addr, server_port)) Socket.send(command) The_Response = library.ReadCommand(Socket) return The_Response
def ForwardCommandToServer(command, server_addr, server_port): """Opens a TCP socket to the server, sends a command, and returns response. Args: command: A single line string command with no newlines in it. server_addr: A string with the name of the server to forward requests to. server_port: An int from 0 to 2^16 with the port the server is listening on. Returns: A single line string response with no newlines. """ transfer_socket = library.CreateClientSocket( server_addr, server_port) # connect to actual server transfer_socket.sendall(command.encode()) # transfer command to server result = library.ReadCommand( transfer_socket) # obtain response from server transfer_socket.close() # close server connection return result
def ProxyClientCommand(sock, server_addr, server_port, cache): """Receives a command from a client and forwards it to a server:port. A single command is read from `sock`. That command is passed to the specified `server`:`port`. The response from the server is then passed back through `sock`. Args: sock: A TCP socket that connects to the client. server_addr: A string with the name of the server to forward requests to. server_port: An int from 0 to 2^16 with the port the server is listening on. cache: A KeyValueStore object that maintains a temorary cache. max_age_in_sec: float. Cached values older than this are re-retrieved from the server. """ command_line = library.ReadCommand(sock) cmd, name, text = library.ParseCommand(command_line) if cmd == "GET": if cache.GetValue(name, MAX_CACHE_AGE_SEC): print('Key %s in the cache.' % name) sock.send("Key: {0}, Value: {1}\n".format( name, cache.GetValue(name, MAX_CACHE_AGE_SEC))) return # Get record from the server, and update the cache. serverResponse = ForwardCommandToServer(command_line, server_addr, server_port) cache.StoreValue(name, serverResponse) elif cmd == "PUT": print('Writing %s: %s to the cache' % (name, text)) cache.StoreValue(name, text) serverResponse = ForwardCommandToServer(command_line, server_addr, server_port) elif cmd == "DUMP": serverResponse = ForwardCommandToServer(command_line, server_addr, server_port) else: return # Forward the server response to the client. print("Forwarding the response from the server to the client") sock.send(serverResponse)
def ForwardCommandToServer(command, server_addr, server_port): """Opens a TCP socket to the server, sends a command, and returns response. Args: command: A single line string command with no newlines in it. server_addr: A string with the name of the server to forward requests to. server_port: An int from 0 to 2^16 with the port the server is listening on. Returns: A single line string response with no newlines. """ proxy_as_client = library.CreateClientSocket(server_addr, server_port) # proxy_as_client.sendto(command, (server_addr, server_port) ) proxy_as_client.send(command) response_from_server = library.ReadCommand(proxy_as_client) # proxy_as_client.close() return response_from_server.strip()
def ProxyClientCommand(client_socket, server_addr, server_port, cache): """Receives a command from a client and forwards it to a server:port. A single command is read from `sock`. That command is passed to the specified `server`:`port`. The response from the server is then passed back through `sock`. Args: sock: A TCP socket that connects to the client. server_addr: A string with the name of the server to forward requests to. server_port: An int from 0 to 2^16 with the port the server is listening on. cache: A KeyValueStore object that maintains a temorary cache. max_age_in_sec: float. Cached values older than this are re-retrieved from the server. """ # Get the client's request/command request = library.ReadCommand(client_socket) cmd, name, text = library.ParseCommand(request) # Forward the request to the server and retrieve response data = ForwardCommandToServer(request, server_addr, server_port) # print("Data is here : {}".format(data)) if cmd == "PUT": if name not in cache.Names(): cache.StoreValue(name, text) client_socket.sendall('%s\n' % data) else: print("Key", name, "already exists") elif cmd == "GET": if name not in cache.Names(): print("Key ", name, " does not exist") else: cache.GetValue(name, MAX_CACHE_AGE_SEC) client_socket.sendall('%s\n' % data) elif cmd == "DUMP": cache.Keys() client_socket.sendall(data) client_socket.close()
def ProxyClientCommand(sock, server_addr, server_port, cache, max_age_in_sec): """Receives a command from a client and forwards it to a server:port. A single command is read from `sock`. That command is passed to the specified `server`:`port`. The response from the server is then passed back through `sock`. Args: sock: A TCP socket that connects to the client. server_addr: A string with the name of the server to forward requests to. server_port: An int from 0 to 2^16 with the port the server is listening on. cache: A KeyValueStore object that maintains a temorary cache. max_age_in_sec: float. Cached values older than this are re-retrieved from the server. """ ########################################### #TODO: Implement ProxyClientCommand ########################################### command_line = library.ReadCommand(sock) command, name, text = library.ParseCommand(command_line) if command == "GET" or command == "get": #if get cached_result = cache.GetValue(command_line, max_age_in_sec) if cached_result is not None: print("Cache used") result = cached_result #if post else: result = ForwardCommandToServer(command_line, server_addr, server_port) cache.StoreValue(command_line, result) elif (command == "PUT" or command == "put"): #if put if (name == None or text == None): result = "Key and Value needed for PUT operation\n" else: result = ForwardCommandToServer(command_line, server_addr, server_port) elif (command == "DUMP" or command == "dump"): #if dump result = ForwardCommandToServer(command_line, server_addr, server_port) else: result = "Invalid Operation\n" sock.send(result)
def ForwardCommandToServer(msg_to_server): """Opens a TCP socket to the server, sends a command, and returns response. Args: msg_to_server: Contains the cmdline, server_addr, and server_port Returns: A single line string response with no newlines. """ command_line, server_addr, server_port = msg_to_server client_socket = library.CreateClientSocket(server_addr, server_port) res = None try: # Relay command_line to server and return the response. client_socket.sendall(command_line.encode()) res = library.ReadCommand(client_socket).strip('\n') finally: client_socket.close() return res
def ProxyClientCommand(sock, server_addr, server_port, cache): """ Receives a command from a client and forwards it to a server:port. A single command is read from `sock`. That command is passed to the specified `server`:`port`. The response from the server is then passed back through `sock`. Args: sock: A TCP socket that connects to the client. server_addr: A string with the name of the server to forward requests to. server_port: An int from 0 to 2^16 with the port the server is listening on. cache: A KeyValueStore object that maintains a temorary cache. max_age_in_sec: float. Cached values older than this are re-retrieved from the server. """ data = library.ReadCommand(sock) response = CheckCachedResponse(data, cache) if not response: result = ForwardCommandToServer(data, server_addr, server_port) sock.sendall((result + "\n").encode('utf-8')) else: sock.sendall((response + "\n").encode('utf-8'))
def ProxyClientCommand(sock, server_addr, server_port, cache): command_line = library.ReadCommand(sock) response = CheckCachedResponse(command_line, cache, server_addr, server_port) sock.send(response)
A single command is read from `sock`. That command is passed to the specified `server`:`port`. The response from the server is then passed back through `sock`. Args: sock: A TCP socket that connects to the client. server_addr: A string with the name of the server to forward requests to. server_port: An int from 0 to 2^16 with the port the server is listening on. cache: A KeyValueStore object that maintains a temorary cache. max_age_in_sec: float. Cached values older than this are re-retrieved from the server. """ ########################################### #TODO: Implement ProxyClientCommand Command_Line = library.ReadCommand(sock) Is_response = CheckCachedResponse(Command_Line, cache, server_addr, server_port) sock.send(Is_response) ########################################### def main(): # Listen on a specified port... Server_Sock = library.CreateServerSocket(LISTENING_PORT) Cache = library.KeyValueStore() # Accept incoming commands indefinitely. while True: # Wait until a client connects and then get a socket that connects to the # client. client_sock, (address, port) = library.ConnectClientToServer(server_sock, SERVER_PORT) print('Received connection from %s:%d' % (address, port))