class BitDrizzle: def __init__(self): self.host = config.host # we don't know until we try to bind to it self.peer_port = config.base_peer_port # we don't know until we try to bind to it self.local_port = config.base_local_port self.myNode = None return def drizzlerSetup(self): MM = 0 # multi mode flag off # the drizzler_thread is of the drizzler class within peer head, # it guides the construction of the net facing node ( kwargs are a place holder, not used ) # the args it takes are for unique ports (peer and app_support, a start # port and the net size while self.peer_port < (config.base_peer_port + config.net_size): try: drizzler_thread = Drizzler(args=(self.host, self.peer_port, self.local_port, config.base_peer_port, config.net_size, MM), kwargs={'a': 'A', 'b': 'B'}) # start the thread drizzler_thread.start() break except: self.peer_port = self.peer_port + 1 self.local_port = self.local_port + 1 return def localSetup(self): # this is the app_support hash table and a listener port self.myNode = LocalHead(self.host, self.local_port) return def go_multi_mode(self): # MM only works from the node at the base_port MM = 1 # multi mode flag if self.peer_port == config.base_peer_port: threads = [] # a container for threads, which we may or may not attempt to search # we'll simulate the growth of the network with the building of # threads, net_size of them in this case peer_port = self.peer_port + 1 local_port = self.local_port + 1 while peer_port < (config.base_peer_port + config.net_size): print(peer_port) try: # the drizzler_thread is of the drizzler class within peer head, # it guides the construction of the net facing node ( kwargs are a place holder, not used ) # the args it takes are for unique ports (peer and # app_support, a start port and the net size drizzler_thread = Drizzler(args=(self.host, peer_port, local_port, config.base_peer_port, config.net_size, MM), kwargs={'a': 'A', 'b': 'B'}) # add the thread to the container, it will be indexed by i, # the offset of the port number, if it s needed threads.append(drizzler_thread) # start the thread, which doesn't happen right away drizzler_thread.start() # we sleep so a thread can take control # starting them in order will generally allow them to # insert into the network in order time.sleep(.1) # However, if the time is set below 0.1, then the threads may conflict with each other # and instead of one large network, many little networks # will emerge except Exception as e: print(e) peer_port = peer_port + 1 local_port = local_port + 1 # this particular thread will wait for the network setup to # conclude print("Standby...") # I suggest setting net_size to 10 or less for development and # sleep to 3 seconds time.sleep(3) return "ALL NETWORK NODE THREADS HAVE STARTED" # P2P Networking API def is_cmd_ready(self): return self.myNode.hasListener() def get_net_neighbors(self, mode): return self.myNode.getNeighbors(mode) def find_net(self): return self.myNode.findPeer() def locate_hash(self, hash): return ("Hash " + hash + " is at " + self.myNode.locateHash(hash)) ''' # # # NETWORKING API THAT NEEDS TO BE IMPLEMENTED # ''' def join_net(self): return self.myNode.joinNetwork() def remove_from_net(self): return self.myNode.leaveNetwork() def get_net_size(self): return self.myNode.networkSize() def set_new_net_size(self): return # data management API def write_to_net(self, data_string: str, piece_size: int) -> str: start_time = time.time() parts = int(len(data_string) / piece_size) last_part = int(len(data_string) % piece_size) # write the full pieces for i in range(0, parts): piece = data_string[(i * piece_size):(i * piece_size) + piece_size] self.myNode.writeToNet(piece) # write the last piece (the remainder) last_piece = data_string[len(data_string) - last_part:len(data_string)] self.myNode.writeToNet(last_piece) total_real_time = time.time() - start_time total_parts = parts + 1 total_bytes = len(data_string) return ("Wrote " + str(total_bytes) + " bytes with " + str(total_parts) + " parts in " + str(total_real_time) + " seconds") def write_local(self, data_string: str, piece_size: int) -> str: start_time = time.time() parts = int(len(data_string) / piece_size) last_part = int(len(data_string) % piece_size) # write the full pieces for i in range(0, parts): piece = data_string[(i * piece_size):(i * piece_size) + piece_size] self.myNode.writeLocal(piece) # write the last piece (the remainder) last_piece = data_string[len(data_string) - last_part:len(data_string)] self.myNode.writeLocal(last_piece) total_real_time = time.time() - start_time total_parts = parts + 1 total_bytes = len(data_string) return ("Wrote " + str(total_bytes) + " bytes with " + str(total_parts) + " parts in " + str(total_real_time) + " seconds") def local_dump(self): return self.myNode.DumpLocalData() def peer_dump(self): return self.myNode.DumpPeerData() ''' # # DATA MANAGEMENT API TO IMPLEMENT # ''' # For the record: Original github code: # def read_from_net(self, hash_code): # return def read_from_net(self, hash_code: str) -> str: start_time = time.time() data = self.myNode.readFromNet(hash_code) total_real_time = time.time() - start_time total_bytes = len(data) return "Read {0} bytes in {1} seconds and got:\n{2}".format(total_bytes, total_real_time, data) # def read_local(self, hash_code): # return self.myNode.readLocal(hash_code) def read_local(self, hash_code: str) -> str: start_time = time.time() data = self.myNode.readLocal(hash_code) total_real_time = time.time() - start_time total_bytes = len(data) return "Read {0} bytes in {1} seconds and got:\n{2}".format(total_bytes, total_real_time, data) # def delete_from_net(self, hash_code): # return self.myNode.deleteFromNet(hash_code) def delete_from_net(self, hash_code: str) -> str: start_time = time.time() data = self.myNode.deleteFromNet(hash_code) total_real_time = time.time() - start_time return "Deleted key {0} in {1} seconds.".format(hash_code, total_real_time) # def delete_local(self, hash_code): # return self.myNode.deleteLocal(hash_code) def delete_local(self, hash_code: str) -> str: start_time = time.time() self.myNode.deleteLocal(hash_code) total_real_time = time.time() - start_time return "Deleted key {0} in {1} seconds.".format(hash_code, total_real_time)
class BitDrizzle: def __init__(self): self.host = config.host self.peer_port = config.base_peer_port #we don't know until we try to bind to it self.local_port = config.base_local_port #we don't know until we try to bind to it self.myNode = None return def drizzlerSetup(self): MM = 0 # multi mode flag off #the drizzler_thread is of the drizzler class within peer head, # it guides the construction of the net facing node ( kwargs are a place holder, not used ) # the args it takes are for unique ports (peer and app_support, a start port and the net size while self.peer_port < (config.base_peer_port + config.net_size): try: drizzler_thread = Drizzler(args=(self.host, self.peer_port, self.local_port, config.base_peer_port, config.net_size, MM), kwargs={'a':'A', 'b':'B'}) #start the thread drizzler_thread.start() break except: self.peer_port = self.peer_port + 1 self.local_port = self.local_port + 1 return def localSetup(self): self.myNode = LocalHead(self.host, self.local_port) # this is the app_support hash table and a listener port return def go_multi_mode(self): # MM only works from the node at the base_port MM = 1 # multi mode flag if self.peer_port == config.base_peer_port: threads = [] # a container for threads, which we may or may not attempt to search # we'll simulate the growth of the network with the building of threads, net_size of them in this case peer_port = self.peer_port + 1 local_port = self.local_port + 1 while peer_port < (config.base_peer_port + config.net_size): print(peer_port) try: #the drizzler_thread is of the drizzler class within peer head, # it guides the construction of the net facing node ( kwargs are a place holder, not used ) # the args it takes are for unique ports (peer and app_support, a start port and the net size drizzler_thread = Drizzler(args=(self.host, peer_port, local_port, config.base_peer_port, config.net_size, MM), kwargs={'a':'A', 'b':'B'}) #add the thread to the container, it will be indexed by i, the offset of the port number, if it s needed threads.append(drizzler_thread) #start the thread, which doesn't happen right away drizzler_thread.start() #we sleep so a thread can take control # starting them in order will generally allow them to # insert into the network in order time.sleep(.1) # However, if the time is set below 0.1, then the threads may conflict with each other # and instead of one large network, many little networks will emerge except Exception as e: print(e) peer_port = peer_port + 1 local_port = local_port + 1 # this particular thread will wait for the network setup to conclude print("Standby...") # I suggest setting net_size to 10 or less for development and sleep to 3 seconds time.sleep(3) return "ALL NETWORK NODE THREADS HAVE STARTED" # P2P Networking API def is_cmd_ready(self): return self.myNode.hasListener() def get_net_neighbors(self, mode): return self.myNode.getNeighbors(mode) def find_net(self): return self.myNode.findPeer() def locate_hash(self, hash): return ("Hash " + hash + " is at " + self.myNode.locateHash(hash)) ''' # # # NETWORKING API THAT NEEDS TO BE IMPLEMENTED # ''' def join_net(self): return self.myNode.joinNetwork() def remove_from_net(self): return def get_net_size(self): return def set_new_net_size(self): return # data management API def write_to_net(self, data_string, piece_size): start_time = time.time() parts = int(len(data_string) / piece_size) last_part = int(len(data_string) % piece_size) # write the full pieces for i in range(0, parts): piece = data_string[(i*piece_size):(i*piece_size)+piece_size] self.myNode.writeToNet(piece) # write the last piece (the remainder) last_piece = data_string[len(data_string)-last_part:len(data_string)] self.myNode.writeToNet(last_piece) total_real_time = time.time() - start_time total_parts = parts + 1 total_bytes = len(data_string) return ("Wrote " + str(total_bytes) + " bytes with " + str(total_parts) + " parts in " + str(total_real_time) + " seconds") def write_local(self, data_string, piece_size): start_time = time.time() parts = int(len(data_string) / piece_size) last_part = int(len(data_string) % piece_size) # write the full pieces for i in range(0, parts): piece = data_string[(i*piece_size):(i*piece_size)+piece_size] self.myNode.writeLocal(piece) # write the last piece (the remainder) last_piece = data_string[len(data_string)-last_part:len(data_string)] self.myNode.writeLocal(last_piece) total_real_time = time.time() - start_time total_parts = parts + 1 total_bytes = len(data_string) return ("Wrote " + str(total_bytes) + " bytes with " + str(total_parts) + " parts in " + str(total_real_time) + " seconds") def local_dump(self): return self.myNode.DumpLocalData() def peer_dump(self): return self.myNode.DumpPeerData() ''' # # DATA MANAGEMENT API TO IMPLEMENT # ''' #def read_from_net(self, hash_code): # return def read_local(self, hash_code): return self.myNode.readLocal(hash_code) def delete_from_net(self, hash_code): return self.myNode.deleteFromNet(hash_code) def delete_local(self, hash_code): return self.myNode.deleteLocal(hash_code)
def localSetup(self): # this is the app_support hash table and a listener port self.myNode = LocalHead(self.host, self.local_port) return
def localSetup(self): self.myNode = LocalHead(self.host, self.local_port) # this is the app_support hash table and a listener port return