def main():
if len(sys.argv) != 2:
print(
"Wrong number of arguments... Please run as such: ./PythonServer.py <port-number>"
)
exit(0)
myIP = socket.gethostbyname(socket.gethostname())
myPort = int(sys.argv[1])
handler = FileStoreHandler(myIP, myPort)
processor = FileStore.Processor(handler)
transport = TSocket.TServerSocket(port=myPort)
tfactory = TTransport.TBufferedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
server = TServer.TSimpleServer(processor, transport, tfactory, pfactory)
print("Starting the Server...")
server.serve()
print("Done serving")
def run_server(port_num):
transport = TSocket.TServerSocket(port=port_num)
tfactory = TTransport.TBufferedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
host_addr = socket.gethostbyname(socket.gethostname())
node_hash = calculate_hash("{0}:{1}".format(host_addr, port_num))
handler = StorageHandler(host_addr, port_num, node_hash)
processor = FileStore.Processor(handler)
server = TServer.TSimpleServer(processor, transport, tfactory, pfactory)
print("Server IP: {0}".format(host_addr))
print("Server Port: {0}".format(port_num))
print("Server Hash: {0}".format(node_hash))
print("Server is started...")
server.serve()
print("Done")
return 0
newTransport = TSocket.TSocket(predNode.ip, predNode.port)
# Buffering is critical. Raw sockets are very slow
newTransport = TTransport.TBufferedTransport(newTransport)
# Wrap in a protocol
newProtocol = TBinaryProtocol.TBinaryProtocol(newTransport)
# Create a client to use the protocol encoder
newClient = FileStore.Client(newProtocol)
# Connect!
newTransport.open()
return newClient.getNodeSucc()
if __name__ == '__main__':
handler = FileStoreHandler(sys.argv[1])
processor = FileStore.Processor(handler)
transport = TSocket.TServerSocket(port=int(sys.argv[1]))
tfactory = TTransport.TBufferedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
server = TServer.TSimpleServer(processor, transport, tfactory, pfactory)
# You could do one of these for a multithreaded server
# server = TServer.TThreadedServer(
# processor, transport, tfactory, pfactory)
# server = TServer.TThreadPoolServer(
# processor, transport, tfactory, pfactory)
print('Starting the server...')
server.serve()
print('done.')
return sNode
break
return cNode
def checkInRange(self, key, n, n1):
if key > n and key < n1:
return True
elif n > n1:
if key < n and key > n1:
return True
else:
return False
else:
return False
if __name__ == '__main__':
sipAddress = socket.gethostbyname(socket.gethostname())
port = int(sys.argv[1])
chord = chordfunc(port, sipAddress)
processor = FileStore.Processor(chord)
transport = TSocket.TServerSocket(port=int(sys.argv[1]))
tfactory = TTransport.TBufferedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
server = TServer.TSimpleServer(processor, transport, tfactory, pfactory)
print('Starting the server...')
#sipAddress = socket.gethostbyname(socket.gethostname())
print('server IP', sipAddress, ' ,' 'port: ', port)
server.serve()
# Validating number of command line arguments
if len(sys.argv) != 2:
print(ERROR_SERVER_ARGV)
sys.exit(1)
print(GENERAL_SERVER_MESSAGE)
# Local variables
server_port_num = int(sys.argv[1])
# Create server side Apache Thrift configurations
fileStoreHandler = ChordServerFileStoreHandler(
server_port_num) # Object to handle File Store RPC calls
server_processor = FileStore.Processor(
fileStoreHandler
) # Mapping of FileStore Processor and File Store Handler
server_socket_transport = TSocket.TServerSocket(
port=server_port_num
) # Server side socket enabled with provided port number
server_tfactory = TTransport.TBufferedTransportFactory(
) # Enable buffering at server side socket
server_pfactory = TBinaryProtocol.TBinaryProtocolFactory(
) # Server protocol to send contents as Binary (marshalling and unmarshalling)
# Creation of simple thrift server object enabled with above configurations
chord_server = TServer.TSimpleServer(server_processor,
server_socket_transport,
server_tfactory, server_pfactory)
print("Server is running ...")
