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 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 test_node_modify_parent(self):
n = Node()
parent = Node(data=1)
n.parent = parent
self.assertEqual(n.parent, parent)
new_parent = Node(data=2)
n.parent = new_parent
self.assertEqual(n.parent, new_parent)
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 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 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)
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 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 __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 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 _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 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_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, 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 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, 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 __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 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):
shared.NODE = Node()
self.log.info("daemon started")
self.log.info("versions:")
self.log.info(" opensvc agent: %s", shared.NODE.agent_version)
self.log.info(" opensvc api: %s", shared.API_VERSION)
self.log.info(" python: %s", sys.version.split()[0])
self.log.info(" crypto module: %s", CRYPTO_MODULE)
caps = capabilities.scan(node=shared.NODE)
self.log.info("%d capabilities:", len(caps))
for cap in caps:
self.log.info(" %s", cap)
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 func(cd=None):
cd_svc = cd or {
"DEFAULT": {
"nodes": "node1 node2"
},
"disk#1": {
"type": "drbd",
"res": "foo",
"disk": "a_disk"
}
}
svc = Svc(name='plop', volatile=True, node=Node(), cd=cd_svc)
return svc.get_resource('disk#1')
def test_interface():
config.input_keys = [0, 1]
config.output_keys = [2, 3]
connections = {
0: Connection(0, 0, 4, 0.2, True),
1: Connection(1, 1, 4, 0.3, True),
2: Connection(2, 4, 2, 0.4, True),
3: Connection(3, 4, 3, 0.5, True),
4: Connection(4, 4, 4, 0.3, True)
}
nodes = {
0: Node(0, 0),
1: Node(1, 0),
2: Node(2, 0),
3: Node(3, 0),
4: Node(4, 0)
}
network_visualizer = NetworkVisualizer()
network_visualizer.update_node_positions(connections, nodes)
network_visualizer.visualize_network(connections)
def test_respect_reboot_once_keyword(mocker, once_value,
remove_reboot_flag):
mocker.patch.object(Node, '_reboot')
reboot_flag = Node().paths.reboot_flag
open(reboot_flag, 'w+')
mocker.patch('core.node.node.assert_file_is_root_only_writeable')
if once_value is not None:
assert commands.node.main(
argv=["set", "--kw",
"reboot.once=%s" % once_value]) == 0
assert commands.node.main(argv=["auto", "reboot"]) == 0
if remove_reboot_flag:
assert not os.path.exists(reboot_flag)
else:
assert os.path.exists(reboot_flag)
def test_raises_on_dup_destinations(mocker, osvc_path_tests,
volume_mounts):
mocker.patch.object(Volume, 'status', return_value=core.status.UP)
svc1 = Svc('svc1')
pool = Pool(name="dir1", node=Node())
for vol_name in ['vol1', 'vol2']:
pool.configure_volume(factory("vol")(name=vol_name))
svc1 += Volume(rid="#" + vol_name, name=vol_name)
container = ContainerDocker(rid='#dck1', volume_mounts=volume_mounts)
svc1 += container
with pytest.raises(ex.Error, match=r'same destination mount point'):
container.volume_options()
def _get_ping_datagram(self):
try:
line = self._file.next()
except (StopIteration):
with self._lock:
self._is_done = True
return
print '>>>>', line
ip, str_port = line.split()
if ip in self._pinged_ips:
#duplicated IP, ignore
return
addr = (ip, int(str_port))
msg = self.msg_f.outgoing_ping_query(Node(addr))
return Datagram(msg.stamp(TID), addr)
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, 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)
def new_node(self, generation_new_nodes, generation_new_connections):
connections_values = list(self.connections.values())
# choose a random connection and disable it
connection = random.choice(connections_values)
connection.enabled = False
key_pair = (connection.from_key, connection.to_key)
# if a node has already been added between these two nodes assign existing innovation numbers and node key
if key_pair in generation_new_nodes:
new_node_key = generation_new_nodes[key_pair]
innovation_number1 = generation_new_connections[(
connection.from_key, new_node_key)]
innovation_number2 = generation_new_connections[(
new_node_key, connection.to_key)]
# otherwise create new and remember structural innovation
else:
new_node_key = config.next_node_key
generation_new_nodes[key_pair] = new_node_key
config.next_node_key += 1
innovation_number1 = config.innovation_number
generation_new_connections[(connection.from_key,
new_node_key)] = innovation_number1
config.innovation_number += 1
innovation_number2 = config.innovation_number
generation_new_connections[(
new_node_key, connection.to_key)] = innovation_number2
config.innovation_number += 1
# create a new node with random bias
bias = random.gauss(config.bias_new_mu, config.bias_new_sigma)
new_node = Node(new_node_key, bias)
self.nodes[new_node_key] = new_node
# create a new connection and set it's value to 1.0
new_connection1 = Connection(innovation_number1, connection.from_key,
new_node_key, 1.0, True)
self.connections[innovation_number1] = new_connection1
# create a new connection and set it's value to the value of disabled connection
new_connection2 = Connection(innovation_number2, new_node_key,
connection.to_key, connection.weight,
True)
self.connections[innovation_number2] = new_connection2
def main(options, args):
id_str, v, ip, port_str = args
id_ = Id(id_str)
port = int(port_str)
bootstrap_node = Node((ip, port), id_, version=v)
mcrawler = MultiCrawler(bootstrap_node)
logs_path = '.' # os.path.join(os.path.expanduser('~'), '.pymdht')
logging_conf.setup(logs_path, logging.DEBUG)
reactor = minitwisted.ThreadedReactor(mcrawler.main_loop,
7005,
mcrawler.on_datagram_received,
task_interval=EXTRACTION_DELAY / 2)
# NO THREADED REACTOR
reactor._lock.acquire = lambda: None
reactor._lock.release = lambda: None
reactor.run2()
