def send(self, worker_id, data):
worker = self.lookup_worker(worker_id)
if worker is None:
log.warning('Worker {0} not available'.format(worker))
return
log.debug('Sending:{0} to {1}'.format(data, worker))
self.connection.send(data, worker)
def handle_ready(self, body):
data = str(body).split(MessageSplit)
log.debug("Ready reply from {0} - {1}".format(data[1], data[2]))
devices = list()
for device in range(3, len(data)):
devices.append(data[device])
self.add_worker(data[1], data[2], devices)
def handle_ready(self, body):
data = str(body).split(MessageSplit)
log.debug("Ready reply from {0} - {1}".format(data[1], data[2]))
devices = list()
for device in range(3, len(data)):
devices.append(data[device])
self.add_worker(data[1], data[2], devices)
def send(self, worker_id, data):
worker = self.lookup_worker(worker_id)
if worker is None:
log.warning('Worker {0} not available'.format(worker))
return
log.debug('Sending:{0} to {1}'.format(data, worker))
self.connection.send(data, worker)
def charts_update(request):
if request.POST:
last_timestamp_ms = request.POST.getlist('timestamp')
worker = request.POST.get('worker')
log.debug('charts log: {0}'.format(last_timestamp_ms))
#last_timestamp = ms_to_datetime(int(last_timestamp_ms[0]))
last_timestamp = datetime.fromtimestamp(float(last_timestamp_ms[0])/1000.0)
last_timestamp = timezone.get_current_timezone().localize(last_timestamp)
log.debug('charts log: {0}'.format(last_timestamp))
#latest_measurement_set = Measurement.objects.filter(device__iexact='Temperature').filter(timestamp__gt=last_timestamp)
latest_measurement_set = Measurement.objects.filter(worker=worker).\
filter(device__iexact='Temperature').filter(timestamp__gt=last_timestamp)
latest_timestamps = list()
latest_probe_temps = list()
latest_set_points = list()
if latest_measurement_set:
for item in latest_measurement_set:
latest_timestamps.append(datetime_to_ms(item.timestamp))
latest_probe_temps.append(item.value)
latest_set_points.append(item.set_point)
update_data = {"latest_set_point": latest_set_points, "latest_probe_temp": latest_probe_temps, "latest_timestamp": latest_timestamps}
#update_data.update(csrf(request))
return HttpResponse(json.dumps(update_data), content_type="application/json")
def process_command(self, body):
data = body.split(MessageSplit)
command = data[0]
if len(data) > 1:
worker_id = data[1]
else:
worker_id = None
if len(data) > 2:
instruction = data[2]
else:
instruction = None
if not hasattr(self, command):
log.error('No such command in Master ({0})'.format(command))
return
method = getattr(self, command)
if command in self.broadcasts.keys():
method()
elif command in self.messages.keys():
method(worker_id)
elif command in self.instructions.keys():
method(worker_id, instruction)
else:
log.debug(
'Master requested to send an unauthorized command: {0}'.format(
command))
def charts_update(request):
if request.POST:
last_timestamp_ms = request.POST.getlist('timestamp')
worker = request.POST.get('worker')
log.debug('charts log: {0}'.format(last_timestamp_ms))
#last_timestamp = ms_to_datetime(int(last_timestamp_ms[0]))
last_timestamp = datetime.fromtimestamp(
float(last_timestamp_ms[0]) / 1000.0)
last_timestamp = timezone.get_current_timezone().localize(last_timestamp)
log.debug('charts log: {0}'.format(last_timestamp))
#latest_measurement_set = Measurement.objects.filter(device__iexact='Temperature').filter(timestamp__gt=last_timestamp)
latest_measurement_set = Measurement.objects.filter(worker=worker).\
filter(device__iexact='Temperature').filter(timestamp__gt=last_timestamp)
latest_timestamps = list()
latest_probe_temps = list()
latest_set_points = list()
if latest_measurement_set:
for item in latest_measurement_set:
latest_timestamps.append(datetime_to_ms(item.timestamp))
latest_probe_temps.append(item.value)
latest_set_points.append(item.set_point)
update_data = {
"latest_set_point": latest_set_points,
"latest_probe_temp": latest_probe_temps,
"latest_timestamp": latest_timestamps
}
#update_data.update(csrf(request))
return HttpResponse(json.dumps(update_data),
content_type="application/json")
def done(self):
log.debug('{0} is sending done to master'.format(self.name), True)
if self.on_done():
message = "{0}{1}{2}{3}{4}".format(MessageDone, MessageSplit,
self.name, MessageSplit,
str(self.session_detail_id))
self.send_to_master(message)
else:
self.report_error('Done failed')
def send_ping(ip=None, port=None):
if ip is None:
ip = settings.MASTER_IP # MessageServerIP
if port is None:
port = settings.MASTER_PORT # MessageServerMasterPort
data = MessagePing
log.debug('Commanding master - {0}'.format(data))
mq = PushConnection(ip, port)
mq.send(data)
def send_ping(ip=None, port=None):
if ip is None:
ip = settings.MASTER_IP # MessageServerIP
if port is None:
port = settings.MASTER_PORT # MessageServerMasterPort
data = MessagePing
log.debug('Commanding master - {0}'.format(data))
mq = PushConnection(ip, port)
mq.send(data)
def listen(self):
self.enabled = True
self.on_start()
while self.enabled:
log.debug("worker is listening", True)
data = self.connection.check()
if data is not None:
self.receive(data)
time.sleep(0)
log.debug('Shutting down worker {0}'.format(self), True)
def resume_all_devices(self):
while self.pausing_all_devices:
time.sleep(1)
log.debug('Resuming all passive devices...')
for i in self.inputs.values():
i.resume_device()
for o in self.outputs.values():
o.resume_device()
log.debug('All passive devices resumed')
self.pausing_all_devices = False
def start_work(worker_id, session_detail_id, ip=None, port=None):
if ip is None:
ip = settings.MASTER_IP # MessageServerIP
if port is None:
port = settings.MASTER_PORT # MessageServerMasterPort
data = MessageWork + MessageSplit + worker_id + MessageSplit + session_detail_id
log.debug('Commanding master - {0}'.format(data))
mq = PushConnection(ip, port)
mq.send(data)
def start_work(worker_id, session_detail_id, ip=None, port=None):
if ip is None:
ip = settings.MASTER_IP # MessageServerIP
if port is None:
port = settings.MASTER_PORT # MessageServerMasterPort
data = MessageWork + MessageSplit + worker_id + MessageSplit + session_detail_id
log.debug('Commanding master - {0}'.format(data))
mq = PushConnection(ip, port)
mq.send(data)
def send_master(command, params=None, ip=None, port=None):
if ip is None:
ip = settings.MASTER_IP # MessageServerIP
if port is None:
port = settings.MASTER_PORT # MessageServerMasterPort
data = command
if params is not None:
data += (MessageSplit + params)
log.debug('Commanding master - {0}'.format(data))
mq = PushConnection(ip, port)
mq.send(data)
def send_master(command, params=None, ip=None, port=None):
if ip is None:
ip = settings.MASTER_IP # MessageServerIP
if port is None:
port = settings.MASTER_PORT # MessageServerMasterPort
data = command
if params is not None:
data += (MessageSplit + params)
log.debug('Commanding master - {0}'.format(data))
mq = PushConnection(ip, port)
mq.send(data)
def info(self):
log.debug('{0} is sending info to master'.format(self.name), True)
if self.on_info():
worker_type = '{0}.{1}'.format(self.__module__, self.__class__.__name__)
message = MessageReady + MessageSplit + self.name + MessageSplit + worker_type
for input_device in self.inputs.keys():
message += (MessageSplit + input_device)
for output_device in self.outputs.keys():
message += (MessageSplit + output_device)
self.send_to_master(message)
else:
self.report_error('Info failed')
def pause_all_devices(self):
if self.pausing_all_devices:
return
self.pausing_all_devices = True
while self.is_any_device_enabled():
log.debug('Trying to pause all passive devices...')
for i in self.inputs.values():
i.pause_device()
for o in self.outputs.values():
o.pause_device()
time.sleep(1)
log.debug('All passive devices paused')
self.pausing_all_devices = False
def is_done(self):
if self.hold_timer is None:
return False
finish = self.finish_time()
if finish is None:
return False
work = self.work_time()
if work is None:
return False
if finish >= work:
return True
log.debug('Time until work done: {0}'.format(work - finish), True)
return False
def listen(self):
Worker.force_workers_off_line()
log.debug('Waiting for worker updates. To exit press CTRL+C')
self.enabled = True
while self.enabled:
data = self.connection.check()
if data is not None:
self.handle(data)
time.sleep(0)
self.stop_all_workers()
Worker.force_workers_off_line()
#Worker.objects.all().delete()
log.debug('Shutting down Brew master')
def listen(self):
Worker.force_workers_off_line()
log.debug('Waiting for worker updates. To exit press CTRL+C')
self.enabled = True
while self.enabled:
data = self.connection.check()
if data is not None:
self.handle(data)
time.sleep(0)
self.stop_all_workers()
Worker.force_workers_off_line()
#Worker.objects.all().delete()
log.debug('Shutting down Brew master')
def work(self, worker_id, session_detail_id):
session_detail_set = SessionDetail.objects.filter(pk=int(session_detail_id))
if len(session_detail_set) == 0:
return
session_detail = session_detail_set[0]
session_detail.begin_work(worker_id)
data = serializers.serialize("json", session_detail_set)
self.send(worker_id, data)
try:
log.debug('Work detail sent to {0}'.format(self.workers[int(worker_id)]))
except Exception as e:
log.debug('Work detail not sent: {0}'.format(e.args[0]))
return True
def read(self):
if self.simulation:
return self.test_temperature
with self.read_write_lock:
fo = open(self.io, mode='r')
probe_crc = fo.readline()[-4:].rstrip()
#log.debug(probe_crc)
if probe_crc != 'YES':
log.debug('Temp reading wrong, do not update temp, wait for next reading')
else:
probe_heat = fo.readline().split('=')[1]
temperature = float(probe_heat)/1000
fo.close()
return temperature
def work(self, worker_id, session_detail_id):
session_detail_set = SessionDetail.objects.filter(
pk=int(session_detail_id))
if len(session_detail_set) == 0:
return
session_detail = session_detail_set[0]
session_detail.begin_work(worker_id)
data = serializers.serialize("json", session_detail_set)
self.send(worker_id, data)
try:
log.debug('Work detail sent to {0}'.format(
self.workers[int(worker_id)]))
except Exception as e:
log.debug('Work detail not sent: {0}'.format(e.args[0]))
return True
def do_import(self, uri):
try:
if uri is None:
return 0
self.recipe_file = uri
log.debug('Loading recipe file {0}...'.format(self.recipe_file))
beer = BeerParser()
recipe_data = beer.get_recipes(self.recipe_file)
self.counter = 0
for item in recipe_data:
name = lookup_brew_name(item).strip()
if name is not None:
# Save to database
brew, sections = create_brew_model(item)
brew.save()
self.counter += 1
s_count = m_count = b_count = f_count = 0
for section in sections:
s_count += 1
s = create_section(section, brew, s_count)
s.save()
for step in section.steps:
brew_step = None
if s.worker_type == 'core.workers.mash.MashWorker':
m_count += 1
brew_step = create_mash_step(step, s, m_count)
elif s.worker_type == 'core.workers.boil.BoilWorker':
b_count += 1
brew_step = create_boil_step(step, s, b_count)
elif s.worker_type == 'core.workers.fermentation.FermentationWorker':
f_count += 1
brew_step = create_fermentation_step(
step, s, f_count)
if brew_step is not None:
brew_step.save()
log.debug('...done loading recipe file {0}'.format(
self.recipe_file))
except Exception as e:
log.error('Failed to load recipes {0} ({1})'.format(
self.recipe_file, e.args[0]))
return self.counter
def do_import(self, uri):
try:
if uri is None:
return 0
self.recipe_file = uri
log.debug("Loading recipe file {0}...".format(self.recipe_file))
beer = BeerParser()
recipe_data = beer.get_recipes(self.recipe_file)
self.counter = 0
for item in recipe_data:
name = lookup_brew_name(item).strip()
if name is not None:
# Save to database
brew, sections = create_brew_model(item)
brew.save()
self.counter += 1
s_count = m_count = b_count = f_count = 0
for section in sections:
s_count += 1
s = create_section(section, brew, s_count)
s.save()
for step in section.steps:
brew_step = None
if s.worker_type == "core.workers.mash.MashWorker":
m_count += 1
brew_step = create_mash_step(step, s, m_count)
elif s.worker_type == "core.workers.boil.BoilWorker":
b_count += 1
brew_step = create_boil_step(step, s, b_count)
elif s.worker_type == "core.workers.fermentation.FermentationWorker":
f_count += 1
brew_step = create_fermentation_step(step, s, f_count)
if brew_step is not None:
brew_step.save()
log.debug("...done loading recipe file {0}".format(self.recipe_file))
except Exception as e:
log.error("Failed to load recipes {0} ({1})".format(self.recipe_file, e.args[0]))
return self.counter
def process_command(self, body):
data = body.split(MessageSplit)
command = data[0]
if len(data) > 1:
worker_id = data[1]
else:
worker_id = None
if len(data) > 2:
instruction = data[2]
else:
instruction = None
if not hasattr(self, command):
log.error('No such command in Master ({0})'.format(command))
return
method = getattr(self, command)
if command in self.broadcasts.keys():
method()
elif command in self.messages.keys():
method(worker_id)
elif command in self.instructions.keys():
method(worker_id, instruction)
else:
log.debug('Master requested to send an unauthorized command: {0}'.format(command))
def pause(self):
log.debug('{0} is sending paused to master'.format(self.name), True)
if not self.on_pause():
self.report_error('Pause failed')
def send_all(self, data):
log.debug('Sending:{0}'.format(data))
self.connection.broadcast(data)
def resume(self):
log.debug('{0} is sending resumed to master'.format(self.name), True)
if not self.on_resume():
self.report_error('Resume failed')
def on_start(self):
log.debug('Starting {0}'.format(self), True)
def on_info(self):
log.debug('Info {0}'.format(self), True)
return True
def on_done(self):
log.debug('Done {0}'.format(self), True)
return True
def on_pause(self):
log.debug('Pause {0}'.format(self), True)
self.pause_all_devices()
self.hold_pause_timer = dt.now()
return True
def on_resume(self):
log.debug('Resume {0}'.format(self), True)
self.pause_time += (dt.now() - self.hold_pause_timer)
self.resume_all_devices()
return True
probe.io = '/sys/bus/w1/devices/28-00000607f0de/w1_slave'
ssr = SSR()
ssr.name = 'Mash Tun'
ssr.io = '/sys/class/gpio/gpio17/value'
# Use built in function to initialize, check if registered and if not register the device
ok, message = probe.auto_setup()
if not ok:
log.error(message)
ok, message = ssr.auto_setup()
if not ok:
log.error(message)
# Example of accessing device data intially read from YAML(here faked)
print ('Device of type {0} is named {1} and uses io path {2}'.format(probe.devicetype(), probe.name, probe.io))
print ('Device of type {0} is named {1} and uses io path {2}'.format(ssr.devicetype(), ssr.name, ssr.io))
# Do something with the devices
ssr.write('1')
log.debug('Turning SSR ON')
time.sleep(5)
ssr.write('0')
log.debug('Turning SSR OFF')
i = 0
while i < 10:
log.debug(probe.read())
time.sleep(1)
i += 1
def reset(self):
log.debug('{0} is resetting'.format(self.name), True)
if self.on_reset():
self.info()
else:
self.report_error('Reset failed')
def send_all(self, data):
log.debug('Sending:{0}'.format(data))
self.connection.broadcast(data)
