def assignMasterSlave(robot1, robot2):
if robot1.type == robot2.type:
printc("On ne peut pas permuter 2 " + robot2.type, 'Fail')
if robot1.type == "Slave":
slave = Slave(robot1.s, robot1.hostname)
master = Master(robot2.s, robot2.hostname)
else:
slave = Slave(robot2.s, robot2.hostname)
master = Master(robot1.s, robot1.hostname)
return master, slave
def GetStations(self):
if (not self.isLoggedIn):
raise Exception("You are not logged in")
try:
slaves = []
r = requests.get(self.address + "/GetStations",
cookies=self.jar,
timeout=1)
stations = json.loads(r.text)
stations = stations["stations"]
for station in stations:
slaves.append(
Slave(int(station["StationID"]), station["Name"],
int(station["refTime"]), station["enableSettings"]))
except RequestException as e:
raise Exception(str(e))
except Exception as e:
raise Exception("Error occurred during slaves loading")
else:
return slaves
def Machine(self, mtype, ip_port, clock_time, logs_file, **kwargs):
i = 0
if mtype is 'm':
master = Master(ip_port, clock_time, logs_file, kwargs['d'],
kwargs['slaves_file'])
while True:
i += 1
print("Execution ", i)
master.get_slaves_time()
master.calculate_time()
time.sleep(5)
elif mtype is 's':
slave = Slave(ip_port, clock_time, logs_file)
from rpyc.utils.server import ThreadedServer
print("Slave machine")
t = ThreadedServer(slave,
port=int(ip_port[ip_port.index(':') + 1:]))
t.start()
else:
print("Option not available")
def run(self):
nb_stack = 0
nb_slave = 0
value = 1
while True:
print("Broadcasting cpu request")
self.__udp_comm.broadcast(self.__commands.get_index("cpu")+";", self.__master.get_cluster_ip_addresses())
data, addr = self.__udp_comm.receive(1024)
print("received message: {} from {}".format(data, addr))
print(data[:-1])
if data[:-1] == b"configure;":#To-Do: check why data is bstr
if(nb_slave <= 5):
stack = self.__master.get_stack(nb_stack)
#To-do : check for ip_address conflict, implement some kind of simple DHCP. May look for DHCP Py libs
new_slave = Slave(nb_stack + RASP_CLASS_ADDRESSES[int(data[10:])-1], nb_stack, "AA:AA:AA:AA:AA:AA", addr[0], int(data.decode().split(";")[1]))
self.__master.get_stack(nb_stack).add_pi_device(new_slave)
value = value + 1
self.__udp_comm.send(self.__commands.get_index("configure") + ";" + addr[0] + ";", new_slave.get_ip_address())
print("Configured new slave of ip_addr {}".format(addr[0]))
nb_slave = nb_slave + 1
else:
nb_stack = nb_stack + 1
new_stack = Stack(nb_stack, nb_stack)
self.__master.add_stack(new_stack)
nb_slave = 0
elif data[:4] == b"cpu;":
cpu_value = data.decode().split(";")[1]
self.__master.get_slave_by_ip(addr[0]).set_cpu_usage(cpu_value)
value = value + 1
print("Received cpu_usage ({}) from slave {}, updating value".format(addr[0], cpu_value))
def __init__(self):
self.master = Master()
self.slave = Slave()
def get_server(self):
if (self.master[0] == self.ip and self.master[1] == self.port):
return Master(self.zookeeper, self.ip, self.socket)
else:
self.socket.close()
return Slave(self.zookeeper, self.master, self.ip)
if __name__ == '__main__':
# initial logger
root.setLevel(logging.DEBUG)
fh = logging.FileHandler('slave.log')
fh.setLevel(logging.DEBUG)
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
fh.setFormatter(formatter)
root.addHandler(fh)
if True:
std = logging.StreamHandler(sys.stdout)
root.addHandler(std)
root.debug('logger stand by...')
slave = Slave()
slave.start()
msgCenter = slave.getMsgCenter()
ec = slave.getEncoder()
lm = slave.getLocalMachine()
while True:
cmd = input(
"start to start, 1 - 5 to change request, stop to stop, t to terminate\n"
)
msg = None
if cmd == "start":
msg = ec.encodeMsg_out("sys", "start transmit", lm.getName())
elif cmd == "stop":
msg = ec.encodeMsg_out("sys", "stop transmit", lm.getName())
elif cmd == "t":
from threading import Thread
from Slave import Slave
from Master import Master
from time import sleep
if __name__ == '__main__':
master = Master()
print("Master tiempo {}".format(master.get_human_time()))
slave1 = Slave(10000)
slave2 = Slave(10001)
slave3 = Slave(10002)
slave4 = Slave(10003)
master.registrar_slave(10000)
master.registrar_slave(10001)
master.registrar_slave(10002)
master.registrar_slave(10003)
print("slave 1 tiempo {}".format(slave1.get_human_time()))
t1 = Thread(target=slave1.escuchar)
t1.start()
print("slave 2 tiempo {}".format(slave2.get_human_time()))
t2 = Thread(target=slave2.escuchar)
t2.start()
print("slave 3 tiempo {}".format(slave3.get_human_time()))
t3 = Thread(target=slave3.escuchar)
t3.start()
print("slave 4 tiempo {}".format(slave4.get_human_time()))
t4 = Thread(target=slave4.escuchar)
t4.start()
master.work()
print("Diferencia media {}[s]".format(master.diferencia_media))
print("Master ajustado tiempo {}".format(master.get_human_time()))
'log_file_path'] if 'log_file_path' in config else tempfile.gettempdir(
) + os.path.sep + 'puha-manager.log'
logging.basicConfig(filename=log_path,
format='%(asctime)s %(message)s',
level=logging.DEBUG)
db_path = config[
'db_file_path'] if 'db_file_path' in config else tempfile.gettempdir(
) + os.path.sep + 'puha-manager-data.db'
Database(db_path)
slaves = []
slave_names = []
for slave_params in config['slaves']:
slaves.append(
Slave(slave_params['ip'], slave_params['port'], slave_params['name'],
config))
slave_names.append(slave_params['name'])
selected_slave_index = 0
slave = slaves[selected_slave_index]
header_data = {
'site_title':
config['site_title'],
'navigation': [{
'url': '/',
'name': 'LED Control'
}, {
'url': '/temperature',
'name': 'Temperature'
}, {
import sys
import os
sys.path.append('src')
from Slave import Slave
import shutil
def copyDirectory(src, dest):
try:
shutil.copytree(src, dest)
# Directories are the same
except shutil.Error as e:
print('Directory not copied. Error: %s' % e)
# Any error saying that the directory doesn't exist
except OSError as e:
print('Directory not copied. Error: %s' % e)
if os.path.exists('Testing/TestImagesTmp'):
shutil.rmtree('Testing/TestImagesTmp')
copyDirectory('Testing/TestImages', 'Testing/TestImagesTmp')
s0 = Slave(name='Slave01',
folder_loc='Testing/TestImagesTmp/Ingest_01',
host='localhost',
port=8080,
debug=True)
s0.setParameters(name='Params', destination='Testing/Params')
s0.run()
