def __init__(self, nodes):
self.nodes = nodes
self.node_manager = NodeManager()
for node in self.nodes:
self.node_manager.add_node(node)
self.node_manager.update_node(node)
self.node_manager.commit(time.time())
self.steps = 0
def test_climb_degree(self):
# intended path:
# 0 -> 2 (largest) -> 9 (largest) -> 4 (smaller number than 7) -> 3 (smaller number than 4)-> 6 (larger), stop
req = MockRequester({
0: {1, 2},
1: {0},
2: {0, 1, 9},
3: {0, 1, 2, 4, 6},
4: {1, 2, 3, 7, 9},
6: {1, 2, 3, 4, 5, 7, 8, 9},
7: {1, 2, 3, 4, 9},
9: {0, 1, 4, 7}
})
nm = NodeManager(req)
output = _run(nm.climb_degree(0))
self.assertEqual(6, output)
def __init__(self, hostid):
"""
Collects resource usage data of host
and nodes.
:param hostid: ROS_IP of this host
:type hostid: string
"""
super(HostStatisticsHandler, self).__init__(hostid)
self.__update_interval = float(0)
self.__publish_interval = 0
self.__is_enabled = False
self.__check_enabled = 0
self.__search_nodes_inv = 0
self.__init_params()
self.__register_service()
self.__lock = threading.Lock()
self.__dict_lock = threading.Lock()
self.pub = rospy.Publisher('/statistics_host',
HostStatistics,
queue_size=500)
#: Used to store information about the host's status.
self._status = HostStatus(rospy.Time.now())
#: Interface to restart and stop nodes
# or executing other commands.
self.__node_manager = NodeManager()
#: Dictionary holding all nodes currently running on the host.
self.__node_list = {}
# Base-stats for I/O
self.__bandwidth_base = {}
self.__msg_freq_base = {}
self.__disk_write_base = {}
self.__disk_read_base = {}
self.__set_bases()
def test_complete_neighbourhood(self):
req = MockRequester({
0: {1, 2, 4, 5},
1: {6},
2: {5},
3: {2, 4},
4: {1},
5: {1, 7},
6: {7},
7: {0, 6}
})
nm = NodeManager(req)
_run(nm.complete_neighbourhood(0))
self._assert_graph(
{
1: {2, 4, 5},
2: {1, 4, 5},
4: {1, 2, 5},
5: {1, 2, 4}
}, req)
def test_distance4(self):
# intended expansion
# dist 0: 0
# dist 1: 1 2 3
# dist 2: 4 5
# dist 3: 6 7
# dist 4: 8 9 10
req = MockRequester({
0: {1, 2, 3},
1: set(), # path that dies out
2: {0, 1}, # paths that return
3: {4, 5, 2},
4: {5, 6},
5: {0, 7},
6: {6, 9}, # path loop
7: {8, 10}
})
nm = NodeManager(req)
output = _run(nm.distance4(0))
self.assertEqual({8, 9, 10}, output)
def test_concurrent_execution(self):
req = MockRequester(
{
0: {1, 2, 3, 4, 5, 6, 7},
1: set(),
2: set(),
3: set(),
4: set(),
5: set(),
6: set(),
7: set()
},
add_sleep=1)
nm = NodeManager(req)
try:
# 7 * 6 / 2 = 21 connections to be added
_run(asyncio.wait_for(nm.complete_neighbourhood(0), timeout=5))
except asyncio.TimeoutError:
self.fail("Timeout reached!")
self._assert_graph({i: (set(range(1, 8)) - {i})
for i in range(1, 8)}, req)
#!/usr/bin/python
import os
import cgi, cgitb
from node_manager import NodeManager
from cgi_utils import send_response
form = cgi.FieldStorage()
node_ids = form.getvalue('node_id_list').split(',')
nm = NodeManager()
for node_id in node_ids:
nm.delete_node(node_id)
send_response({}, 0)
import threading
import time
from jobs import ScanJobManager
from node_manager import NodeManager
scm = ScanJobManager()
scm.NewJob(addr=("178.62.120.181", 80))
nm = NodeManager(scm)
def APIThread():
nm.StartRegistrationListener()
def CreateJobThread():
scm.GenerateJobs()
def SpreadJobThread():
while True:
nm.SpreadJobs(scm)
time.sleep(10)
t_api = threading.Thread(target=APIThread)
t_api.start()
t_create_job = threading.Thread(target=CreateJobThread)
t_create_job.start()
def addNode(self, machineSpec):
self.nodes.append(NodeManager(self, machineSpec))
from process_things import process_rawtx, process_rawblock
from node_manager import NodeManager
import os
from ptpdb import set_trace
controller = NodeManager(zmq_url=os.environ.get("ZMQ_URL"), )
controller.set_on_rawtx(process_rawtx)
controller.set_on_rawblock(process_rawblock)
controller.listen_to_subscriptions()
# For some logging magic
print("")
print("")
from aiogram import Bot, Dispatcher, executor, types
from node_manager import NodeManager
from keyboards import new_keyboard, new_inline_keyboard
import configurer
bot = Bot(configurer.config['BOT']['token'])
dp = Dispatcher(bot)
node_client = NodeManager()
@dp.message_handler(commands=["start"])
async def start_message(message: types.Message):
node_client.add_user(message.chat.id, message.from_user.username)
node = node_client.get_start_node()
keyboard = new_keyboard(node.buttons)
await message.answer(node.text, reply_markup=keyboard)
@dp.message_handler(content_types=['text'])
async def send_text(message: types.Message):
node = node_client.get_node_id(message)
if node_client.check_inline_reply(node.node_id):
keyboard = new_inline_keyboard(node.text)
await message.answer("Переходи по ссылке:", reply_markup=keyboard)
else:
if node.text is not configurer.config['REPLY']['unfinished'] \
and node.action is None:
node_client.change_status(message)
keyboard = new_keyboard(node.buttons)
await message.answer(node.text, reply_markup=keyboard)
node1 = Node(1, 0)
node2 = Node(2, 0)
manager.add_node(node1)
manager.add_node(node2)
while True:
print("Fetching data from fog node...")
header, node = serial_interface.receive_message(self.ser)
# header = 'data'
# node1.energy_level = random.randint(1, 50)
# node2.energy_level = random.randint(1,50)
print(f'Header: {header}')
if header == DATA_HEADER:
print(f'\t{node}')
self.node_manager.update_node(node)
elif header == ADD_NODE_HEADER:
self.node_manager.add_node(node)
elif header == REMOVE_NODE_HEADER:
self.node_manager.remove_node(node.node_id)
elif header == COMMIT_HEADER:
self.node_manager.commit(time.time())
print(f'\tSending orders...')
serial_interface.send_action(self.ser, 1, Action.GATHER)
serial_interface.send_action(self.ser, 2, Action.CHARGE)
manager = NodeManager()
listener = DataListener(manager)
plotter = Plotter(manager)
listener.start()
plt.show()
def __init__(self, *args, **kwargs):
super(UnitTesting, self).__init__(*args, **kwargs)
self.node_manager = NodeManager()
