def __init__(self, objects=None, node=None): if objects is None: objects = [] self.objects = objects self.filtering = len(objects) > 0 self.arrays = [] if node: self.node = node else: self.node = Node() done = [] for s in self.node.conf_sections(cat="array"): name = s.split("#", 1)[-1] if name in done: continue if self.filtering and name not in self.objects: continue try: stype = self.node.oget(s, "type") except: continue if stype != "ibmsvc": continue try: username = self.node.oget(s, 'username') key = self.node.oget(s, 'key') except: print("error parsing section", s, file=sys.stderr) continue self.arrays.append(IbmSvc(name, username, key, node=self.node))
def __init__ ( self, xml_node = None ) : # Node.__init__( self, xml_node ) if xml_node is None : self.type = 'connector' self.name = self.label = self.type if DEBUG_MODE : print ( ">> ConnectorNode( %s ).__init__" % self.label )
def __call__(self, argv=None): """ Instanciate a Node object. Call the real deal making sure the node is finally freed. """ ret = 0 if self.node is None: try: self.node = Node() except Exception as exc: print(exc, file=sys.stderr) return 1 check_privs() try: ret = self._main(argv=argv) except ex.Error as exc: print(exc, file=sys.stderr) return 1 except ex.Version as exc: print(exc) return 0 except KeyboardInterrupt: return 1 finally: self.node.close() if ret is None: ret = 0 return ret
def __init__ ( self, xml_node = None ): # Node.__init__( self, xml_node ) self.imageName = '' print ">> ImageNode __init__"
def test_node_delete_parent(self): n = Node() parent = Node() n.parent = parent self.assertEqual(n.parent, parent) n.parent = None self.assertEqual(n.parent, None)
def __init__ ( self, xml_node = None ) : # Node.__init__( self, xml_node ) if xml_node is None : self.type = 'connector' self.name = self.label = self.type if DEBUG_MODE : print ">> ConnectorNode( %s ).__init__" % self.label
def main(argv=None): if argv is None: argv = sys.argv else: argv.insert(0, __file__) try: node = Node() except Exception as exc: print(exc, file=sys.stderr) return 1 try: _main(node, argv) return 0 except ex.Error as e: if str(e): print(e, file=sys.stderr) return 1 except KeyboardInterrupt: sys.stderr.write("Keybord Interrupt\n") return 1 finally: node.close() return 0
def test_node_add_multiple_children_then_delete_one(self): n = Node() left = Node("left") right = Node("right") n.add_child(left) n.add_child(right) n.remove_child("left") self.assertEqual(n.children, dict(right=right))
def test_suicide_with_invalid_method_log_warning(mocker): node = Node() mocker.patch.object(node.log, 'warning') node.suicide(method="invalid_split_action", delay=6) expected_warning_calls = [ call('invalid commit suicide method %s', 'invalid_split_action'), ] node.log.warning.assert_has_calls(expected_warning_calls)
def __init__(self, **kwargs): logging.info('Bridge.__init__: entry:\n{}'.format( pprint.PrettyPrinter().pformat(kwargs))) Node.__init__(self, **kwargs) self._ssh_credentials = kwargs.get('ssh_credentials') self._ip = kwargs.get('ssh_address')
def run(self, restrict, pt=False): up_n = self.noise[0] left_n = self.noise[1] right_n = self.noise[2] if len(self.noise) > 3: down_n = self.noise[3] else: down_n = 0 # Init table for row in range(0, self.size): for col in range(0, self.size): if self.table[row][col] is None: self.table[row][col] = Node(0, 0, 0, 0, terminal=False) else: value = self.table[row][col] self.table[row][col] = Node(value, value, value, value, terminal=True) self.print_table() print() stable = False while not stable: r = 0 c = 0 temp_table = copy.deepcopy(self.table) for row in temp_table: for col in row: col: Node if col.terminal is not True: # Relative up (Main direction always is up) for i in range(0, 4): col.set_dir(i) col.score[i] = self.gamma * (self.find(r, c, col.d_up) * up_n + self.find(r, c, col.d_left) * left_n + self.find(r, c, col.d_right) * right_n + self.find(r, c, col.d_down) * down_n) col.go_opt_dir() c += 1 c = 0 r += 1 # Check stable delta = 0 for row in range(0, self.size): for col in range(0, self.size): delta += temp_table[row][col].opt_score - self.table[row][col].opt_score if delta < restrict: stable = True self.table = temp_table if pt is True: self.print_table() time.sleep(0.5) print() self.count += 1
def __init__(self, objects=None, node=None): if objects is None: objects = [] self.objects = objects self.filtering = len(objects) > 0 if node: self.node = node else: self.node = Node() done = [] for s in self.node.conf_sections(cat="array"): try: name = self.node.oget(s, "name") except Exception: name = None if not name: name = s.split("#", 1)[-1] if name in done: continue if self.filtering and name not in self.objects: continue try: stype = self.node.oget(s, "type") except: continue if stype != "hds": continue try: bin = self.node.oget(s, 'bin') jre_path = self.node.oget(s, 'jre_path') url = self.node.oget(s, 'url') username = self.node.oget(s, 'username') password = self.node.oget(s, 'password') except Exception as exc: print("error parsing section %s: %s" % (s, exc), file=sys.stderr) continue try: secname, namespace, _ = split_path(password) password = factory("sec")(secname, namespace=namespace, volatile=True).decode_key("password") except Exception as exc: print("error decoding password: %s", exc, file=sys.stderr) continue self.arrays.append( Array(name, url, username, password, bin=bin, jre_path=jre_path, node=self.node)) done.append(name)
def __init__ ( self, xml_node = None ) : # Node.__init__ ( self, xml_node ) if xml_node is None : self.type = 'nodegroup' self.name = self.label = self.type self.nodenet = NodeNetwork () if DEBUG_MODE : print '>> GroupNode( %s ).__init__' % self.label
class Arrays(object): arrays = [] def __init__(self, objects=None, node=None): if objects is None: objects = [] self.objects = objects self.filtering = len(objects) > 0 if node: self.node = node else: self.node = Node() done = [] for s in self.node.conf_sections(cat="array"): try: name = self.node.oget(s, "name") except Exception: name = None if not name: name = s.split("#", 1)[-1] if name in done: continue if self.filtering and name not in self.objects: continue try: stype = self.node.oget(s, "type") except: continue if stype != "xtremio": continue try: api = self.node.oget(s, 'api') username = self.node.oget(s, 'username') password = self.node.oget(s, 'password') except: print("error parsing section", s, file=sys.stderr) continue try: secname, namespace, _ = split_path(password) password = factory("sec")(secname, namespace=namespace, volatile=True).decode_key("password") except Exception as exc: print("error decoding password: %s", exc, file=sys.stderr) continue self.arrays.append(Array(name, api, username, password, node=self.node)) done.append(name) def __iter__(self): for array in self.arrays: yield(array) def get_array(self, name): for array in self.arrays: if array.name == name: return array return None
def __init__(self, objects=None, node=None): if objects is None: objects = [] self.objects = objects self.filtering = len(objects) > 0 if node: self.node = node else: self.node = Node() done = [] for s in self.node.conf_sections(cat="array"): name = s.split("#", 1)[-1] if name in done: continue try: stype = self.node.oget(s, "type") except: continue if stype != "eva": continue try: manager = self.node.oget(s, 'manager') username = self.node.oget(s, 'username') password = self.node.oget(s, 'password') sssubin = self.node.oget(s, 'bin') except Exception as exc: print("error parsing section %s: %s" % (s, exc), file=sys.stderr) pass try: secname, namespace, _ = split_path(password) password = factory("sec")(secname, namespace=namespace, volatile=True).decode_key("password") except Exception as exc: print("error decoding password: %s", exc, file=sys.stderr) continue out, err = sssu('ls system', manager, username, password, sssubin=sssubin) _in = False for line in out.split('\n'): if 'Systems avail' in line: _in = True continue if not _in: continue name = line.strip() if self.filtering and name not in self.objects: continue self.arrays.append( Eva(name, manager, username, password, sssubin=sssubin)) done.append(name)
def __init__(self, objects=None, node=None): if objects is None: objects = [] self.objects = objects if len(objects) > 0: self.filtering = True else: self.filtering = False self.arrays = [] if node: self.node = node else: self.node = Node() done = [] for s in self.node.conf_sections(cat="array"): name = s.split("#", 1)[-1] if name in done: continue if self.filtering and name not in self.objects: continue try: stype = self.node.oget(s, "type") except: continue if stype != "centera": continue try: server = self.node.oget(s, "server") username = self.node.oget(s, "username") password = self.node.oget(s, "password") jcass_dir = self.node.oget(s, "jcass_dir") java_bin = self.node.oget(s, "java_bin") except: print("error parsing section", s, file=sys.stderr) try: secname, namespace, _ = split_path(password) password = factory("sec")(secname, namespace=namespace, volatile=True).decode_key("password") except Exception as exc: print("error decoding password: %s", exc, file=sys.stderr) continue self.arrays.append( Centera(name, server=server, username=username, password=password, java_bin=java_bin, jcass_dir=jcass_dir, node=self.node)) done.append(name)
def test_tree_print_with_two_children(self): root = Node(name="first_level") t = Tree(root=root, name="root") left = Node(name="second_level_one") right = Node(name="second_level_two") t.root.add_child(left) t.root.add_child(right) expected = ( "<Tree 'root'>\n<Node first_level>\n\t<Node second_level_one>\n\t") expected += "<Node second_level_two>" # ... self.assertEqual(str(t), expected)
class IbmDss(object): def __init__(self, objects=None, node=None): if objects is None: objects = [] self.objects = objects self.filtering = len(objects) > 0 self.arrays = [] if node: self.node = node else: self.node = Node() done = [] for s in self.node.conf_sections(cat="array"): name = s.split("#", 1)[-1] if name in done: continue if self.filtering and name not in self.objects: continue try: stype = self.node.oget(s, "type") except: continue if stype != "ibmds": continue pwfile = os.path.join(Env.paths.pathvar, s + '.pwfile') if not os.path.exists(pwfile): raise ex.Error( "%s does not exists. create it with 'dscli managepwfile ...'" % pwfile) try: username = self.node.oget(s, "username") hmc1 = self.node.oget(s, "hmc1") hmc2 = self.node.oget(s, "hmc2") except Exception as exc: print("error parsing section %s: %s" % (s, exc), file=sys.stderr) continue self.arrays.append( IbmDs(name, hmc1, hmc2, username, pwfile, node=self.node)) done.append(name) def __iter__(self): for array in self.arrays: yield (array) def get(self, array): for o in self.arrays: if o.name == array: return o raise ex.Error( "%s not defined in the node/cluster configuration, or is not usable" % array)
def main(argv=None): node = Node() try: return _main(node, argv=argv) except ex.Error as exc: print(exc, file=sys.stderr) return 1 except ex.Version as exc: print(exc) return 0 finally: node.close()
def test_node_add_then_get_children(self): n = Node() left = Node() right = Node() n.add_child(left) n.add_child(right) self.assertEqual(set(n.children.values()), set([left, right]))
def __init__(self, head, log=None, node=None): self.object_type_cache = {} self.head = head self.auto_prefix = "svc:/system/filesystem/zfs/auto-sync:" self.username = None self.password = None self.port = 2000 if node: self.node = node else: self.node = Node() if log is not None: self.log = log else: self.log = self.node.log
def __init__(self, **kwargs): logging.info('OVS.Port.__init__: entry:\n{}'.format( pprint.PrettyPrinter().pformat(kwargs))) port_data = kwargs.pop('port_data') kwargs['name'] = port_data['name'] kwargs['id'] = str(port_data['_uuid']) kwargs['metadata'] = port_data Node.__init__(self, **kwargs) self._ssh_credentials = kwargs.get('ssh_credentials') self._ip = kwargs.get('ssh_address') self._interfaces = None
class Game: def __init__(self): self.dices = [] self.startGame() self.root.printTree() self.result = self.root.bestResult() def startGame(self): self.root = Node(None, self.initBoard(),0) self.gameLoop() def gameLoop(self): done = False while not done: done = self.root.play(self.getRoll()) def getRoll(self): total = 0 for dice in self.dices: total += dice.roll() return total def initBoard(self): for x in range(0,2): self.dices.append(Dice()) tiles = [] for x in range(1,13): tiles.append(x) return tiles
class Game: def __init__(self): self.dices = [] self.startGame() self.root.printTree() self.result = self.root.bestResult() def startGame(self): self.root = Node(None, self.initBoard(), 0) self.gameLoop() def gameLoop(self): done = False while not done: done = self.root.play(self.getRoll()) def getRoll(self): total = 0 for dice in self.dices: total += dice.roll() return total def initBoard(self): for x in range(0, 2): self.dices.append(Dice()) tiles = [] for x in range(1, 13): tiles.append(x) return tiles
def __init__(self, **kwargs): logging.info('OVS.Interface.__init__: entry:\n{}'.format( pprint.PrettyPrinter().pformat(kwargs))) intf_data = kwargs.pop('interface_data') kwargs['name'] = intf_data['name'] kwargs['id'] = intf_data['_uuid'] kwargs['metadata'] = intf_data Node.__init__(self, **kwargs) self._ssh_credentials = kwargs.get('ssh_credentials') self._ip = str(kwargs.get('ssh_address')) self._type = self.metadata['type'] self._ifindex = self.metadata.get('ifindex', None)
def _get_node_from_file(self): try: line = self._file.next() except (StopIteration): return ip, str_port = line.split() return Node((ip, int(str_port)))
def scan(self, node=None): from core.objects.svcdict import SECTIONS from utilities.drivers import iter_drivers if node is None: from core.node import Node node = Node() data = self.scan_generic() data += self.scan_os() for mod in iter_drivers(SECTIONS): if not hasattr(mod, DRIVER_CAP_FN): if hasattr(mod, "DRIVER_GROUP") and hasattr( mod, "DRIVER_BASENAME"): # consider the driver active by default data += [ "%s%s.%s" % (DRIVER_CAP_PREFIX, mod.DRIVER_GROUP, mod.DRIVER_BASENAME) ] continue try: data += [ DRIVER_CAP_PREFIX + cap for cap in getattr(mod, DRIVER_CAP_FN)(node=node) ] except Exception as exc: print(mod, exc, file=sys.stderr) data = sorted([cap for cap in set(data)]) with open(Env.paths.capabilities, "w") as f: json.dump(data, f) return data
def __init__(self, objects=None, node=None): if objects is None: objects = [] self.objects = objects self.filtering = len(objects) > 0 self.timeout = 10 if node: self.node = node else: self.node = Node() done = [] for s in self.node.conf_sections(cat="array"): try: name = self.node.oget(s, 'name') except Exception: name = None if not name: name = s.split("#", 1)[-1] if name in done: continue if self.filtering and name not in self.objects: continue try: stype = self.node.oget(s, "type") except: continue if stype != "dorado": continue timeout = self.node.oget(s, "timeout") try: username = self.node.oget(s, "username") password = self.node.oget(s, "password") api = self.node.oget(s, "api") except: print("error parsing section", s, file=sys.stderr) continue try: secname, namespace, _ = split_path(password) password = factory("sec")(secname, namespace=namespace, volatile=True).decode_key("password") except Exception as exc: print("error decoding password: %s", exc, file=sys.stderr) continue self.arrays.append( Dorado(name, api, username, password, timeout, node=self.node)) done.append(name)
class Netapps(object): def __init__(self, objects=None, node=None): if objects is None: objects = [] self.objects = objects self.filtering = len(objects) > 0 self.arrays = [] if node: self.node = node else: self.node = Node() done = [] for s in self.node.conf_sections(cat="array"): name = s.split("#", 1)[-1] if name in done: continue if self.filtering and name not in self.objects: continue try: stype = self.node.oget(s, "type") except: continue if stype != "netapp": continue kwargs = {"node": self.node} for key in ("server", "username", "key"): try: kwargs[key] = self.node.oget(s, key) except: print("missing parameter: %s", s) if "server" not in kwargs or "username" not in kwargs or "key" not in kwargs: continue try: secname, namespace, _ = split_path(kwargs["password"]) kwargs["password"] = factory("sec")( secname, namespace=namespace, volatile=True).decode_key("password") except Exception as exc: print("error decoding password: %s", exc, file=sys.stderr) continue self.arrays.append(Netapp(s, **kwargs)) def __iter__(self): for array in self.arrays: yield (array)
def test_create_call_node_create_service(mocker, mock_sysname, sysname): mock_sysname(sysname) node_create_service = mocker.patch.object(Node, 'create_service', return_value=None) assert Mgr(selector='svc1', node=Node())(["create"]) == 0 assert node_create_service.call_count == 1
def test_respect_hook_result(mocker, has_node_config, hook, value, reboot_counts, expected_exit_code): _reboot = mocker.patch.object(Node, '_reboot') open(Node().paths.reboot_flag, 'w+') mocker.patch('core.node.node.assert_file_is_root_only_writeable') assert commands.node.main( argv=["set", "--kw", "reboot.%s=%s" % (hook, value)]) == 0 assert commands.node.main( argv=["auto", "reboot"]) == expected_exit_code assert _reboot.call_count == reboot_counts
def __init__(self, pop): # population correspondant à l'individu self.population = pop # Création de l'arbre de décision associé à l'individu self.decision_tree = Node() self.current_node = None self.notify = False self.notify_drown = False self.inside_tree = False self.last_coord = (0, 0) self.shoot_nb = 0
def replace_node(target_node: Node, node_name: str, new_ip: str = "", new_port: str = "0", alert_master=False, kill_original=False): """ Replace a node with an attacker controlled Node. Can optionally kill the original :param target_node: Node to replace :param node_name: The name to give for ros exploits :param new_ip: IP address for the node to use if blank the node will be created on local host :param new_port: Port for the node to use. If 0 the node will open a port first :param alert_master: Boolean value. If true replace the node in the masters graph, if false updates to the state do not reach the new node :param kill_original: Boolean Value. If true kill the original node as part of execution :return: """ new_node = Node(ip_addr=new_ip, port=new_port, notes="Evil node") node_uri = "http://" + new_ip + ":" + new_port target_node.get_pub_list(node_name=node_name) target_node.get_pub_list(node_name=node_name) # TODO: Let the other nodes know about the replacement for topic in target_node.pub_topics: new_node.pub_topics.append(copy.copy(topic)) for topic in target_node.sub_topics: new_node.sub_topics.append(copy.copy(topic)) if alert_master: (_, _, master_url) = target_node.server.getMasterUri(node_name) master = xmlrpc.client.ServerProxy(master_url) for topic in new_node.pub_topics: master.registerPublisher(node_name, topic.name, topic.message_type, node_uri) # TODO: Create connections to subscriber for topic in new_node.sub_topics: master.registerSubscriber(node_name, topic.name, topic.message_type, node_uri) if kill_original: target_node.server.shutdown(node_name, "")
def main(options, args): id_str, ip, port_str = args port = int(port_str) node_to_extract = Node((ip, port), Id(id_str)) table_extractor = TableExtractor(node_to_extract) logs_path = os.path.join(os.path.expanduser('~'), '.pymdht') logging_conf.setup(logs_path, logging.DEBUG) reactor = minitwisted.ThreadedReactor(table_extractor.main_loop, 7000, table_extractor.on_datagram_received) reactor.start() time.sleep(30)
def __init__ ( self, xml_node = None ) : # Node.__init__ ( self, xml_node ) self.ribName = ''
def __init__(self, **kwargs): logging.info('openstack.node.__init__: entry:\n{}'.format(pprint.PrettyPrinter().pformat(kwargs))) Node.__init__(self, **kwargs)
def __init__ ( self, xml_node = None ): # Node.__init__ ( self, xml_node ) self.shaderName = '' print ">> RSLNode __init__"
def copySetup ( self, newNode ) : # if DEBUG_MODE : print '>> GrouphNode( %s ).copySetup ' % self.label Node.copySetup ( self, newNode ) newNode.nodenet = self.nodenet.copy ()
def __init__ ( self, xml_node = None ) : # Node.__init__ ( self, xml_node ) self.imageName = '' if DEBUG_MODE : print ( '>> ImageNode( %s ).__init__' % self.label )
def __init__ ( self, xml_node = None ) : # Node.__init__ ( self, xml_node ) self.shaderName = ''
def startGame(self): self.root = Node(None, self.initBoard(),0) self.gameLoop()
def __init__ ( self, xml_node = None ) : # Node.__init__( self, xml_node ) if DEBUG_MODE : print ">> NoteNode __init__"
def load(self, location: bytes): node = Node.from_bytes(self.database[location]) self.cache[location] = node
def add(self, node: Node): """Add a node to the current database.""" save = node.to_bytes() self.database[node.sha] = save self.cache[node.sha] = node
def __init__ ( self, xml_node = None ): # Node.__init__ ( self, xml_node ) self.ribName = '' print ">> RIBNode __init__"
def __init__(self, **kwargs): logging.info('onos.Controller.__init__: entry:\n{}'.format(pprint.PrettyPrinter().pformat(kwargs))) Node.__init__(self, **kwargs)