def collect_nodes(self): """Return network information scraped from CloudTrax""" for network in self.network['networks']: parameters = {'id': network, 'showall': '1', 'details': '1'} logging.info('Requesting network status') request = self.session.get(self.url['data'], params=parameters) logging.info('Received network status ok') if request.status_code == 200: for raw_values in distill_html(request.content, 'table', {'id': 'mytable'}): node = Node(raw_values, self.get_checkin_data(raw_values[2][0]), network) if node.is_alerting(): logging.info('%s is alerting' % (node)) self.alerting.append(node) self.nodes[node.get_mac()] = node else: logging.error('Request failed') exit(request.status_code) return self.nodes
def url(request, project, env): from lib.node import Node from lib.common import Common result = "" n = Node(project, env) ip = [] for row in n.get(): if row["hostname"].startswith("Controltier"): continue ip.append(row["hostname"]) for vrow in Validation.objects.filter(project=project).values(): for server in ip: if vrow["url"].startswith("ip"): url = re.sub("ip", server, vrow["url"]) return_code = Common().get_return_code(url, vrow["port"]) result += """ <tr> <th>{url}</th> <th>{return_code}</th> </tr> """.format( url=url, return_code=return_code ) return HttpResponse(result)
def url(request, project, env): from lib.node import Node from lib.common import Common result = "" n = Node(project, env) ip = [] for row in n.get(): if row['hostname'].startswith("Controltier"): continue ip.append(row['hostname']) for vrow in Validation.objects.filter(project=project).values(): for server in ip: if vrow['url'].startswith("ip"): url = re.sub("ip", server, vrow['url']) return_code = Common().get_return_code(url, vrow['port']) result += """ <tr> <th>{url}</th> <th>{return_code}</th> </tr> """.format( url=url, return_code=return_code, ) return HttpResponse(result)
def decode_headers(self, bitStream: 'BitStream', char_size: int): if bitStream.read(1).bin == '1': encoded_char: str = bitStream.read(char_size).bin int_char: int = int(encoded_char, 2) return Node(symbol=chr(int_char)[0], count=1) else: left = self.decode_headers(bitStream, char_size) right = self.decode_headers(bitStream, char_size) return Node(left=left, right=right, count=1)
def __init__(self, component_class, name="ctrl", max_callbacks=0): Node.__init__(self, name, 0) ctxt = Context(self) self.component_object = component_class(ctxt=ctxt) self.connection_count = 0 self.in_connections = {} self.callbacks = [] self.start_callbacks = [] self.max_callbacks = max_callbacks
def test_position_validity(): for i in range(1000): rdn = random.random() if rdn > 0.5: pos = -1 * (random.randint(1, 1000)) node = Node(State.DEAD, pos) assert (node.valid_node == False) else: pos = random.randint(1, 1000) node = Node(State.DEAD, pos) assert (node.valid_node == True)
def copyNode(self, node): """Copy a node object add it on manager list nodes and set it not include. Return the new node object. """ # newNode = copy.copy(node) # newNode.homeId = 0 nodeId = self.getFirstFreeNodeIdBeforeInclude() newNode = Node(self, 0, nodeId, node.GetXmlData) newNode.ClearAddingNode() newNode.Reset() self._nodes.append(newNode) self._log.write(LogLevel.Info, self, "Manager create new node by copy node {0}.{1}.".format(node.homeId, node.nodeId)) return newNode
def __init__(self, name, port_count, of_id, expire_entries=False): Node.__init__(self, name, port_count) self.log = logging.getLogger("nice.mc.%s" % self.name) self.flow_table_object = [] self.openflow_id = of_id self.buffers = [] self.next_buffer_id = 0 self.packet_store = {} self.command_queue = [] self.fault_injection_count = 0 self.state_cnt = 0 self.expire_entries = expire_entries self.ports_to_fail = [] self.this_switch_is_offline = False
def __init__(self, start, target, allow_diagonals, World): self.start = Node(start, target, 0, None, World, False, allow_diagonals) self.target = Node(target, target, 0, None, World, False, allow_diagonals) self.reached = False self.stack = [self.start] self.visited = [] self.path = [] while (not (self.start.is_accessible())): stdout.write("\033[;1m" + "\033[1;31m") stdout.write('START Tile have no children, choose another one ! ') stdout.write("\033[0;0m") start = int(input("New START Tile ---> ")) self.start = Node(start, target, 0, None, World, False, allow_diagonals, True) while (not (self.target.is_accessible())): stdout.write("\033[;1m" + "\033[1;31m") stdout.write('TARGET Tile have no children, choose another one ! ') stdout.write("\033[0;0m") target = int(input("New TARGET Tile ---> ")) self.target = Node(target, target, 0, None, World, False, allow_diagonals, True) self.path = [self.start.tile_pos] self.costs = [0]
def __init__(self, start, target, allow_diagonals, World): self.start = Node(start, target, 0, None, World, False, allow_diagonals) self.target = Node(target, target, -1, None, World, False, allow_diagonals) self.open_nodes = [self.start] self.closed_nodes = [] self.last_node = None self.reached = False self.available_tiles = World.list_available_tiles() while (not(self.start.is_accessible())): stdout.write("\033[;1m" + "\033[1;31m") stdout.write('START Tile have no children, choose another one ! ') stdout.write("\033[0;0m") start = int(input("New START Tile ---> ")) self.start = Node(start, target, 0, None, World, False, allow_diagonals) while (not(self.target.is_accessible())): stdout.write("\033[;1m" + "\033[1;31m") stdout.write('TARGET Tile have no children, choose another one ! ') stdout.write("\033[0;0m") target = int(input("New TARGET Tile ---> ")) self.target = Node(target, target, -1, None, World, False, allow_diagonals) self.path = [self.start.tile_pos] self.costs = [0]
def test_state_validity(): for i in range(1000): rdn = random.random() if rdn > 0.5: state = random.choice(State.ALLOWED_) node = Node(state, 0) assert (node.valid_node == True) else: state = random.randint(-1000, 1000) if state in State.ALLOWED_: pass else: node = Node(state, 0) assert (node.valid_node == False)
def getInfoMock(self, return_value): Node._infoCInfo.return_value = return_value Node._infoTelnet.return_value = return_value n = Node("127.0.0.1") return n
def add_node(self, node_name, children=None): if node_name in self.nodes: raise GraphDuplicateNodeNameError( "Attempting to create a duplicately-named node in the same graph." ) self.nodes[node_name] = Node(node_name, children)
def setUp(self): self.cluster_patch = patch('lib.cluster.Cluster') #self.view_patch = patch('lib.view.CliView') real_stdoup = sys.stdout sys.stdout = StringIO() self.addCleanup(patch.stopall) self.addCleanup(reset_stdout) self.MockCluster = self.cluster_patch.start() #self.MockView = self.view_patch.start() Cluster._crawl = classmethod(lambda self: None) Cluster._callNodeMethod = classmethod( lambda self, nodes, method_name, *args, **kwargs: {"test":IOError("test error")}) n = Node("172.99.99.99") Cluster.getNode = classmethod( lambda self, key: [n]) pd = PrefixDict() pd['test'] = 'test' Cluster.getPrefixes = classmethod(lambda self: pd) self.rc = RootController()
def test_outofbounds(): env = World(10, 10, 0.2) free_tiles = env.list_available_tiles() new_node = [Node(i, 84, 0, None, env) for i in free_tiles] for elem in new_node: assert (elem.tile_pos >= 0 and elem.tile_pos <= (env.L * env.H))
def prepare(self): """Create a router with its nodes.""" debug('Creating {}:'.format(self.role), self.name) self.nodes = [] for hypervisor in self.hypervisors: if self.deployment.high_available: suffix = self.suffixes[self.hypervisors.index(hypervisor)] self.nodes.append(Node(self, hypervisor, suffix)) else: self.nodes.append(Node(self, hypervisor)) break for i, node in enumerate(self.nodes): if len(self.nodes) == 2: node.peer_node = self.nodes[(i + 1) % 2] if i == 1: node.is_secondary = True
def test_availability(): env = World(10, 10, 0.2) free_tiles = env.list_available_tiles() new_node = [Node(i, 84, 0, None, env) for i in free_tiles] for elem in new_node: assert (env.w[elem.tile_pos] != 1)
def addXmlNode(self, homeId, nodeId, xmlNode): for n in self._nodes: if n.homeId == homeId and n.nodeId == nodeId: self._log.write(LogLevel.Warning, self, "Node {0} on homeId {1} from xml config file allready exist, abording add.".format(nodeId, homeId)) return None node = Node(self, homeId, nodeId, xmlNode) self._nodes.append(node) self._log.write(LogLevel.Info, self, "Node {0} on homeId {1} added from xml config file.".format(nodeId, homeId))
class NodeTest(unittest.TestCase): def setUp(self): self.node = Node(movie_score=60, movie_title="Hot Tub Time Machine") def test_it_exists(self): self.assertIsInstance(self.node, Node) def test_attributes(self): self.assertEqual(self.node.movie_score, 60) self.assertEqual(self.node.movie_title, "Hot Tub Time Machine") def test_left_is_none_by_default(self): self.assertEqual(self.node.left, None) def test_right_is_none_by_default(self): self.assertEqual(self.node.right, None) def test_depth_is_none_by_default(self): self.assertEqual(self.node.depth, 0) def test_insert_left(self): self.node.insert(56, "Bill & Ted's Excellent Adventure") self.assertEqual(self.node.left.movie_score, 56) self.node.insert(50, "Die Hard") self.assertEqual(self.node.left.left.movie_score, 50) self.assertEqual( self.node.insert(50, "Jingle Bells"), "That movie score has already been used. Please submit another one" ) def test_insert_right(self): self.node.insert(64, "Bill & Ted's Excellent Adventure") self.assertEqual(self.node.right.movie_score, 64) self.node.insert(70, "Die Hard") self.assertEqual(self.node.right.right.movie_score, 70) self.assertEqual( self.node.insert(60, "Jingle Bells"), "That movie score has already been used. Please submit another one" )
def dump_equivalent_state(self): filtered_dict = Node.dump_equivalent_state(self) filtered_dict["command_queue"] = [] for c in self.command_queue: utils.copy_state(c) filtered_dict["flow_table"] = utils.copy_state(self.flow_table) filtered_dict["packet_store"] = utils.copy_state(self.packet_store) if self.ALWAYS_NEW_STATE: filtered_dict["state_cnt"] = utils.copy_state(self.state_cnt) return filtered_dict
def get_node_tree(self, frequencies: List['Node']) -> 'Node': priority_queue = PriorityQueue(frequencies) while True: left_node = priority_queue.get_and_remove_first_element() right_node = priority_queue.get_and_remove_first_element() parent = Node(left=left_node, right=right_node) if (len(priority_queue) == 0): return parent priority_queue.add(parent)
def dump_equivalent_state(self): filtered_dict = Node.dump_equivalent_state(self) filtered_dict["component"] = utils.copy_state(self.component) filtered_dict["in_connections"] = {} keys = self.in_connections.keys() keys.sort() for j in keys: filtered_dict["in_connections"][j] = [] for m in self.in_connections[j][1]: filtered_dict["in_connections"][j].append(utils.copy_state(m)) # get only the buffer return filtered_dict
def _registerNode(self, ip_port): """ Instantiate and return a new node If cannot instantiate node, return None. Creates a new node if: 1) node.key doesn't already exist 2) node.key exists but existing node is not alive """ try: ip, port = ip_port except Exception as e: print "ip_port is expected to be a tuple of len 2, " + \ "instead it is of type %s and str value of %s"%(type(ip_port) , str(ip_port)) return None try: node_key = Node.createKey(ip, port) if node_key in self.nodes: existing = self.nodes[node_key] else: existing = None if not existing or not existing.alive: new_node = Node(ip, port, use_telnet=self.use_telnet, user=self.user, password=self.password) if existing and not new_node.alive: new_node = existing self.updateNode(new_node) return new_node except: return None
def dump_equivalent_state(self): filtered_dict = Node.dump_equivalent_state(self) filtered_dict["component"] = utils.copy_state(self.component) filtered_dict["in_connections"] = {} keys = self.in_connections.keys() keys.sort() for j in keys: filtered_dict["in_connections"][j] = [] for m in self.in_connections[j][1]: filtered_dict["in_connections"][j].append( utils.copy_state(m)) # get only the buffer return filtered_dict
def test_uniqueness(): env = World(10, 10, 0.2) free_tiles = env.list_available_tiles() nodes = [Node(i, 84, 0, None, env) for i in free_tiles] # list of positions pos = [] for elem in nodes: pos.append(elem.tile_pos) # check uniqueness seen = set() uniqueness = not any(k in seen or seen.add(k) for k in pos) assert (uniqueness == True)
def __initNodes(self, map): self.nodes = [] for x in range(self.pNum): self.nodes.append([]) for y in range(self.pNum): startPos = (x * self.pWidth, y * self.pHeight) nodeState = 0 if map == maps.zebra: nodeState = states.empty if y % 2 == 0 else states.wall elif map == maps.windows: pLast = self.pNum - 1 if (x + 1) % 3 == 0 and y != pLast: nodeState = states.empty elif (y % 2 == 0 or y == pLast) and (x, y) not in [ (0, 0), (1, 0), (pLast, pLast - 1), (pLast - 1, pLast - 1) ]: nodeState = states.wall elif map == maps.coolerWindows: if (x + 1) % 3 == 0: nodeState = states.empty elif y % 2 == 0: if 0 in [x % 6, (x - 1) % 6]: nodeState = states.wall else: if 0 in [(x + 3) % 6, (x + 2) % 6]: nodeState = states.wall elif map == maps.yourComputerWillCrash: if (x, y) != (0, 0) or (y != self.pNum or x != self.pNum): if x % 4 == 0 and y == 0: nodeState = states.empty elif x % 2 == 0 and y <= x: nodeState = states.wall if (y + 2) % 4 == 0 and x == 0: nodeState = states.empty elif y % 2 == 0 and y > x: nodeState = states.wall self.nodes[-1].append( Node(startPos, (self.pWidth, self.pHeight), state=nodeState))
def test_testcase1(self): """ 测试用例如下: implementation:s0 -act1?-> s1 specification: s0 -act1?-> s1 :return: None """ imp_root = Node(None, State("s0")) imp_root.children = [ Node(Action("act1", ActionEnum.INPUT), State("s1")) ] spec_root = Node(None, State("s0")) spec_root.children = [ Node(Action("act1", ActionEnum.INPUT), State("s1")) ] imp = LTSTree(imp_root) spec = LTSTree(spec_root) self.assertTrue(imp.io_conform(spec), msg="io not conform")
def create_node(self,e): nodeList = get_variable("nodeList") properties = get_variable("properties") #check position x = e.x y = e.y for item in nodeList: iX = item._x iY = item._y if( x > iX - 20 and x < iX + 50 and y > iY - 20 and y < iY + 50): return #create new node newNode = Node(self._canvas,"",0,x-15,y-15,30) nodeList.append(newNode) properties.target_node(newNode)
def create_new_child(self): if(self.target == None): return nodeList = get_variable("nodeList") children = self.target._childNodes x = None y = None if(children == []): x = self.target._x + 20 y = self.target._y + 80 else: x = children[-1]["Node"]._x + 50 y = children[-1]["Node"]._y newChild = Node(self.target._canvas,"",0,x,y,30) nodeList.append(newChild) self.target.add_child(newChild,0) self.target_node(newChild)
def _registerNode(self, ip_port): """ Instantiate and return a new node If cannot instantiate node, return None. Creates a new node if: 1) node.key doesn't already exist 2) node.key exists but existing node is not alive """ try: ip, port = ip_port except Exception as e: print "ip_port is expected to be a tuple of len 2, " + \ "instead it is of type %s and str value of %s"%(type(ip_port) , str(ip_port)) return None try: node_key = Node.createKey(ip, port) if node_key in self.nodes: existing = self.nodes[node_key] else: existing = None if not existing or not existing.alive: new_node = Node(ip , port , use_telnet=self.use_telnet , user=self.user , password=self.password) if existing and not new_node.alive: new_node = existing self.updateNode(new_node) return new_node except: return None
class Root: # region 用户自定义函数区域 def __init__(self): self.sub_demo = Node(SubDemo) pass @staticmethod def demo(args): form = request.form.to_dict() except_keys = ['argument1', 'argument2'] real_keys = form.keys() attachment = request.files.get("attachment") if except_keys == list(real_keys) and attachment is not None: return else: print(args) print(form) return {'code': 500, 'msg': '参数错误'} @staticmethod def data_demo(args): print('headers:', request.headers) print('args:', request.args) # params print('cookies:', request.cookies) print('data:', request.data) # json print('form:', request.form) # form return f'This is a demo url return!\n{str(args)}' def sub_demo(self, args): form = request.form.to_dict() except_keys = ['argument1', 'argument2'] real_keys = form.keys() if except_keys == list(real_keys): return {'code': 200, 'msg': '参数错误', 'data': 1000} else: print(form) return self.sub_demo.action(*args)
def start(self, model_checker): Node.start(self, model_checker) for callback in self.start_callbacks: callback() self.start_callbacks = None
def getInfoMock(self, return_value): Node.info = mock.Mock() n = Node("127.0.0.1") return n
def __init__(self, epochs, population, infectProb, healProb, deathProb, World, n_infected=1, spreadRange=1): self.epochs = epochs self.hardstop = 0 self.spreadRange = spreadRange self.population = population self.infectProb = infectProb self.healProb = healProb self.deathProb = deathProb self.world = World self.worldHistory = [] self.n_infected = n_infected self.has_spread = False self.nodes = dict() self.deaths_n = 0 self.healthy = [] self.cured = [] self.infected = [] self.dead = [] free_tiles = World.list_available_tiles() free_tiles_n = len(free_tiles) if not (isinstance(population, int)): print( ColorsBook.WARNING + "Careful, population has to be an INT : forcing it at closest number" + ColorsBook.ENDC) population = int(population) if population > free_tiles_n: print( ColorsBook.WARNING + "Careful, population higher than allocated space : forcing it at maximum" + ColorsBook.ENDC) population = free_tiles_n if population < 0: print( ColorsBook.WARNING + "Careful, population can't be negative : forcing it at random number" + ColorsBook.ENDC) population = random.randint(1, free_tiles_n) self.population = population if epochs <= 0 or not (isinstance(epochs, int)): print( ColorsBook.FAIL + "Negative or Zero number of EPOCHS is not allowed, terminating..." + ColorsBook.ENDC) sys.exit() if (infectProb or healProb or deathProb) < 0 or (infectProb or healProb or deathProb) > 1: print( ColorsBook.FAIL + "Probabilities not included between [0, 1] interval, terminating..." + ColorsBook.ENDC) sys.exit() if (spreadRange > 1): print(ColorsBook.WARNING + "Careful, spreading range unsupported, forcing it at 1" + ColorsBook.ENDC) self.spreadRange = 1 elif (spreadRange < 0): print(ColorsBook.WARNING + "Careful, spreading range unsupported, forcing it at 0" + ColorsBook.ENDC) self.spreadRange = 0 elif (not (isinstance(spreadRange, int))): print( ColorsBook.WARNING + "Careful, spreading range unsupported (should be int), forcing to random choice between 0 and 1" + ColorsBook.ENDC) self.spreadRange = round(random.random()) if (n_infected < 0): print( ColorsBook.WARNING + "Careful, initial number of infected can't be negative, forcing it at 1" + ColorsBook.ENDC) self.n_infected = 1 elif (not (isinstance(n_infected, int))): print( ColorsBook.WARNING + "Careful, initial number of infected must be int, forcing it at closest int" + ColorsBook.ENDC) self.n_infected = int(n_infected) # Generates Nodes at random available spot for i in range(self.population): random.shuffle(free_tiles) picked_spot = free_tiles.pop() self.world.pos_matrix[picked_spot] = State.UNAFFECTED self.nodes[picked_spot] = Node(State.UNAFFECTED, picked_spot)
def dump_equivalent_state(self): filtered_dict = Node.dump_equivalent_state(self) filtered_dict["arp_table"] = utils.copy_state(self.arp_table) return filtered_dict
def __init__(self, name, mymac, myip): Node.__init__(self, name, 1) self.mymac = MacAddress(mymac) self.myip = IpAddress(myip) self.arp_table = {}
def start(self, model_checker): Node.start(self, model_checker) for p in self.ports_to_fail: self.enableAction("link_fault_down", p)
def start(self, model_checker): Node.start(self, model_checker)