def retrieve_login_code(self, request_date=datetime.now()): print("Retrieving login code.") try: self.outlook.select_folder('INBOX') emails_from_joe = self.outlook.search([ 'FROM', '*****@*****.**', 'SUBJECT', 'FW: Login code' ]) if emails_from_joe: raw_message = self.outlook.fetch( [emails_from_joe[-1]], ['BODY[]', 'FLAGS', 'ENVELOPE']) for key, value in raw_message.items(): timestamp = value[b'ENVELOPE'].date if timestamp < request_date: print( f"Emails from Joe exist. However, latest email is {timestamp.strftime('%m/%d/%Y %H:%M:%S')} which is before {request_date.strftime('%m/%d/%Y %H:%M:%S')}. Waiting 30 seconds." ) sleep(30) return self.retrieve_login_code(request_date) body = str(value[b'BODY[]']) codes = re.findall(r"\\n([0-9]+)<", body) return codes[0] print("Emails from Joe do not exist. Waiting 60 seconds.") sleep(60) return self.retrieve_login_code(request_date) except: if not NetworkManager().is_connected(): print("Network issue.") sleep(90) self.retrieve_login_code(request_date) else: print(f"Unexpected error: {sys.exc_info()[0]}")
def __init__(self): self.settings = Settings() self.credentials = Credentials() self.display = Display() self.networkManager = NetworkManager() self.previous_hour1 = self.previous_hour2 = -1 self.previous_minute1 = self.previous_minute2 = -1 self.previous_second2 = self.previous_count = -1 self.loop = get_event_loop() rst_cause = reset_cause() if rst_cause in [PWRON_RESET, SOFT_RESET]: self.power_on_reset_wkfl() elif rst_cause in [HARD_RESET]: self.hard_reset_wkfl() elif rst_cause == DEEPSLEEP_RESET: self.deepsleep_reset_wkfl() else: self.other_reset_wkfl() self.loop.run_forever() self.loop.close()
def mpls_remove_fns(desc): fns_id= libnetvirt.getUuidFromFNS(desc) print "remove id " + str(fns_id) + "num of endpoints: " + str(libnetvirt.getNepFromFNS(desc)) #libnetvirt.printFNS(desc) D = Database ('libnetvirt.sqlite') for i in range(0,libnetvirt.getNepFromFNS(desc)): ep = libnetvirt.getEndpoint(desc,i) r_id = libnetvirt.getSwIdFromEp(ep) # Get router name #r_name = str(libnetvirt.getSwIdFromEp(ep)) r_name = D.getRouterName(r_id) # Get the router user name r_uname = D.getRouterUserName(r_id) vlan = libnetvirt.getVlanFromEp(ep) pe_if = libnetvirt.getPortFromEp vrf = 'vrf' + str(fns_id) #Calling the scripts for configuration. Uncomment when the network is available NM = NetworkManager(r_name, r_uname) if NM != None: NM.stop_configuration(vlan, vrf,pe_if) NM.close_ssh() else: print "Error in applying configuration" return 0
def main(): network = NetworkManager() json_string = network.getPresence() seats = json.loads(json_string) db_manager = DBManager() for item in seats: db_manager.create_seat(item)
def __init__(self): self.network_manager = NetworkManager(self.state_changer) self.running = True self.labels, self.entries, self.buttons = dict(), dict(), dict() self.root = Tk() self.override_data = BooleanVar() self.override_data.set(True) self.tk_root_setup()
def mpls_create_fns(desc): print "create fns" #libnetvirt.printFNS(desc) fns_id= libnetvirt.getUuidFromFNS(desc) D = Database ('libnetvirt.sqlite') for i in range(0,libnetvirt.getNepFromFNS(desc)): ep = libnetvirt.getEndpoint(desc,i) r_id = libnetvirt.getSwIdFromEp(ep) # Get router name #r_name = str(libnetvirt.getSwIdFromEp(ep)) r_name = D.getRouterName(r_id) # Get the router user name r_uname = D.getRouterUserName(r_id) # Get the router interface r_interface = D.getRouterInterface(r_id)+str(libnetvirt.getPortFromEp(ep)) #r_uname = "root" #r_interface = "eth3" r_d_net = '192.66.23.0' pe_address = libnetvirt.getAddressFromEp(ep) #ce_address = libnetvirt.getAddressCEFromEp(ep) #we need net address for CE tmp = commands.getoutput('ipcalc -n ' + str(pe_address)) tmp = tmp.split() ce_net = tmp[16] vlan = libnetvirt.getVlanFromEp(ep) vrf = 'vrf' + str(fns_id) #get address from global configuration database r_d = r_d_net + ':' + str(fns_id) #call script for PE configuration #Calling the scripts for configuration. Uncomment when the network is available NM = NetworkManager(r_name, r_uname) if NM != None: NM.start_configuration(r_interface, pe_address, ce_net, r_d, vlan, vrf) NM.close_ssh() else: print "Error in applying configuration" return 0
def SendCommandMessage(target): commandMessage = MessageFactory.createCommandMessage( target, 'hello world') NetworkManager().outgoingMessages.put(commandMessage)
import NetworkConstants if __name__ == '__main__': global MY_NAME MY_NAME = 'CHRONOS' def SendCommandMessage(target): commandMessage = MessageFactory.createCommandMessage( target, 'hello world') NetworkManager().outgoingMessages.put(commandMessage) initialise() # Initialise the network API sleep(1) InsTable().printTable() otherIsaacs = NetworkManager().getConnectedDevices() if (len(otherIsaacs) > 0): target = otherIsaacs[0] pingDevice(target) sendCommand(target, 'KILL SELF') sleep(5) running = True while running: userInput = input('Enter command (type QUIT or EXIT to terminate):\n') userInput = userInput.upper()
from NetworkManager import NetworkManager from time import sleep if __name__ == '__main__': nm = NetworkManager(NetworkManager.MODE_CLIENT_SERVER, NetworkManager.ROLL_CLIENT, '127.0.0.1', 50007) nm.client_open() nm.transmit_data(NetworkManager.DST_SERVER, "HELLO WORLD") while True: sleep(1)
def menu(): options = {1:"network inventory info.",2:" all devices info.",3:"device info.",4:"device description.(!!!!)"} print "------------------------------" print "MENU" print "------------------------------" for key in options.keys(): print str(key) + ")Print " + options[key] choise = raw_input("Enter: ") return int(choise) if __name__ == "__main__": #print "Starting network manager..." try: print "Starting network manager..." nm = NetworkManager('192.168.111.138') print "Network manager started." while(1): option = menu() if option == 1: nm.printInventory() elif option == 2: nm.printDeviceInfo() elif option == 3: info_type = raw_input("Enter information type: ") device_id = raw_input("Enter device_id: ") nm.printDataForDevice(info_type.rstrip(),device_id.rstrip()) else: exit() except Exception,exception:
class SimulationCreator: __simulation = Simulation() __networkManager = NetworkManager() __sensorsManager = SensorsManager(__networkManager) __tripManager = TripManager(__networkManager) def __init__(self): SimulationCreator.__simulation = Simulation() SimulationCreator.__networkManager = NetworkManager() SimulationCreator.__sensorsManager = SensorsManager(SimulationCreator.__networkManager) SimulationCreator.__tripManager = TripManager(SimulationCreator.__networkManager) # -------------------------------- Net file creation ------------------------------------------------ def set_map_box(self, mapBox): SimulationCreator.__simulation.set_map_box(mapBox) def get_map_box(self): return SimulationCreator.__simulation.get_map_box() #Call NetworkManager to create map.net.xml def create_network_file(self): project_directory = SimulationCreator.__networkManager.create_project_directory() network_file_path = SimulationCreator.__networkManager.get_network_file( SimulationCreator.__simulation.get_map_box() ) SimulationCreator.__simulation.set_project_directory_path(project_directory) SimulationCreator.__simulation.set_network_file(network_file_path) # Generate a new network file including splitted edges def split_network_edges(self): SimulationCreator.__networkManager.generate_network_file_with_splitted_edges( SimulationCreator.__simulation.get_flows(), SimulationCreator.__simulation.get_sensors_distance() ) # --------------------------------------------------------------------------------------------------- # -------------------------------- Flows definition ------------------------------------------------- def define_traffic_flows(self, inFlowPoints, outFlowPoints): self.flows_file_path, self.flows = SimulationCreator.__tripManager.generate_flows_file(inFlowPoints, outFlowPoints) SimulationCreator.__simulation.set_flows(self.flows) def create_route_file(self): self.route_file = SimulationCreator.__tripManager.generate_route_file(self.flows_file_path) SimulationCreator.__tripManager.set_vehicle_types_in_route_file(self.route_file) SimulationCreator.__simulation.set_route_file(self.route_file) SimulationCreator.__simulation.add_vehicle_types(self.get_vehicle_types()) # --------------------------------------------------------------------------------------------------- # ---------------------------------- Incident lanes definition -------------------------------------- def add_incidents(self, incidents): #Calculate each incident edge_id before setting them in simulation instance incident_updated_lanes = SimulationCreator.__tripManager.set_incident_lanes(incidents) SimulationCreator.__simulation.add_incidents(incident_updated_lanes) Sink.incidents = incident_updated_lanes # --------------------------------------------------------------------------------------------------- # ---------------------------------- Vehicle types defintion ---------------------------------------- def add_vehicle_type(self, vehicle_type): SimulationCreator.__tripManager.add_vehicle_type(vehicle_type) SimulationCreator.__simulation.add_vehicle_types([vehicle_type]) def set_vehicle_types_percentages(self, vehicle_types_percentages): SimulationCreator.__tripManager.set_vehicle_types_percentages(vehicle_types_percentages) def get_vehicle_types(self): return SimulationCreator.__tripManager.get_vehicle_types() # --------------------------------------------------------------------------------------------------- # ------------------------------------- Add sensors ------------------------------------------------- def set_sensors_distance(self, distance): SimulationCreator.__simulation.set_sensors_distance(distance) def create_sensors(self): LaneChange.EdgeLength = SimulationCreator.__simulation.get_sensors_distance() self.sinks, self.sensors, self.sensors_file = SimulationCreator.__sensorsManager.create_sensors( SimulationCreator.__simulation.get_flows(), SimulationCreator.__simulation.get_incidents() ) SimulationCreator.__simulation.add_sensors(self.sensors) SimulationCreator.__simulation.add_sinks(self.sinks) SimulationCreator.__simulation.set_sensors_file(self.sensors_file) # --------------------------------------------------------------------------------------------------- # ------------------------------------- Simulation Creation ----------------------------------------- def set_sim_duration(self, duration): SimulationCreator.__simulation.set_duration(duration) #Create Simulation Config file 'map.sumocfg' def createSimulation(self): SimulationCreator.__simulation.create_sumo_config_file() return SimulationCreator.__simulation
def __init__(self): SimulationCreator.__simulation = Simulation() SimulationCreator.__networkManager = NetworkManager() SimulationCreator.__sensorsManager = SensorsManager(SimulationCreator.__networkManager) SimulationCreator.__tripManager = TripManager(SimulationCreator.__networkManager)
def train(self): if not os.path.exists('weights/'): os.makedirs('weights/') previous_acc = 0.0 total_reward = 0.0 policy_sess = tf.Session() K.set_session(policy_sess) with policy_sess.as_default(): # create the Controller and build the internal policy network controller = Controller(policy_sess, self.num_conv_layers, self.state_space, reg_param=self.regularization, exploration=self.exploration, controller_cells=self.num_control_cells, embedding_dim=self.embedding_dim, restore_controller=self.restore_model) # create the Network Manager manager = NetworkManager(self. dataset, epochs=self.num_epochs, child_batchsize=self.batch_size, clip_rewards=self.clip_rewards, acc_beta=self.accuracy_beta) # create the Model Constructor constructor = ModelConstructor(self.input_size, self.output_size, self.num_conv_layers, self.num_dense_layers, self.dense_config) # get an initial random state space if controller needs to predict an # action from the initial state state = self.state_space.init_random_states(self.num_conv_layers) print state print("Initial Random State : ", self.state_space.parse_state_space_list(state)) print() # clear the previous files controller.remove_files() # train for number of trails for trial in range(self.num_trials): with policy_sess.as_default(): K.set_session(policy_sess) actions = controller.get_action(state) # get an action for the previous state # print the action probabilities self.state_space.print_actions(actions) print("Predicted actions: ", self.state_space.parse_state_space_list(actions, local=True)) # build a model, train and get reward and accuracy from the network manager reward, previous_acc = manager.get_rewards(constructor, self.state_space.parse_state_space_list(actions, local=True)) print("Rewards: ", reward, "Accuracy: ", previous_acc) with policy_sess.as_default(): K.set_session(policy_sess) total_reward += reward print("Total reward: ", total_reward) # actions and states are equivalent, save the state and reward first_state = state[0] state = actions controller.store_rollout(state, reward) # train the controller on the saved state and the discounted rewards loss = controller.train_step(first_state) print("Trial %d: Controller loss: %0.6f" % (trial + 1, loss)) print() print("Total Reward: ", total_reward)
def __init__(self, passed_config): self.state = SYNC_STATE.STOP self.config = passed_config self.network = NetworkManager(passed_config)
def __init__(self): self.clients = {} self.network_manager = NetworkManager(self.clients) print("Init done, server started")