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 parse_config(configfile=defaults.DEFAULT_CONFIG):
try:
config = core.config.Config(configfile)
return config
except Exception as e:
log.error('Unable to parse config: {0}'.format(e.args[0]))
return None
def handle_measurement(self, worker_measurement_data):
#log.debug('Receiving worker measurement...')
try:
with self.measurements_lock:
worker_measurement = WorkerMeasurement.deserialize_message(
worker_measurement_data)
measurement = Measurement()
measurement.worker = worker_measurement.worker_name
session_detail_id = worker_measurement.session_detail_id
session_detail = SessionDetail.objects.get(
pk=session_detail_id)
measurement.session_detail = session_detail
measurement.device = worker_measurement.device_name
measurement.value = worker_measurement.value
measurement.set_point = worker_measurement.set_point
measurement.work = worker_measurement.work
measurement.remaining = worker_measurement.remaining
if not worker_measurement.debug_timer is None: # In simulation mode, use fake timestamps
#measurement.timestamp = datetime.strptime(worker_measurement.debug_timer, "%Y-%m-%d %H:%M:%S.%f")
#measurement.timestamp = dt.get_current_timezone.localize(measurement.timestamp)
measurement.timestamp = worker_measurement.debug_timer
else:
measurement.timestamp = dt.now()
measurement.save()
except Exception as e:
log.error(
'Master could not save measurement to database ({0})'.format(
e.args[0]))
def parse_config(configfile=defaults.DEFAULT_CONFIG):
try:
config = core.config.Config(configfile)
return config
except Exception as e:
log.error('Unable to parse config: {0}'.format(e.args[0]))
return None
def run_device(self):
if self.enabled:
return
if hasattr(self.owner, self.callback_name):
self.callback = getattr(self.owner, self.callback_name)
else:
log.error('Callback function {0} not found for owner {1}'.format(self.callback_name, self.owner))
self.auto_setup()
self.start()
def send(self, data, worker=""):
try:
if worker == "":
self.master_socket.send_string(data)
else:
data = "{0}#{1}".format(worker, data)
self.master_socket.send_string(data)
except Exception as e:
log.error('Error sending message {0} ({1})'.format(data, e))
def finish(self):
try:
self.pause_all_devices()
self.working = False
self.done()
self.session_detail_id = 0
return True
except Exception as e:
log.error('Error in cleaning up after work: {0}'.format(e.args[0]), True)
return False
def run_device(self):
if self.enabled:
return
if hasattr(self.owner, self.callback_name):
self.callback = getattr(self.owner, self.callback_name)
else:
log.error('Callback function {0} not found for owner {1}'.format(
self.callback_name, self.owner))
self.auto_setup()
self.start()
def check(self):
try:
if self.queue == CONNECTION_MASTER_QUEUE:
return self.worker_socket.recv_string()
else:
data = self.worker_socket.recv_string()
pos = data.find("#")
data = data[pos+1:]
return data
except Exception as e:
log.error('Error receiving message ({0})'.format(e))
def load_device(config, owner, simulation):
try:
device_instance = construct_class_instance(config.device_class, config)
if not issubclass(device_instance.__class__, core.devices.device.Device):
log.error('Unable to load device from config: {0} is not a subclass of core.devices.device.Device'.
format(config.class_name))
return None
device_instance.owner = owner
device_instance.simulation = simulation
return device_instance
except Exception as e:
log.error('Unable to load device from config: {0}'.format(e.args[0]))
return None
def brews_import(request):
uri = None
try:
if request.POST:
index = int(request.POST['index'])
file = request.FILES['file']
filename = request.FILES['file'].name
uri = os.path.dirname(os.path.realpath(__file__))
uri += '/importing/uploaded_files/'
uri += filename
fd = open(uri, 'wb')
for chunk in file.chunks():
fd.write(chunk)
fd.close()
brew_importer.BrewImporter.import_brews(index, uri)
except Exception as e:
try:
if uri is not None:
log.error('Failed to upload file {0} : {1}'.format(uri, e.args[0]))
else:
log.error('Failed to upload file : {0}'.format(e.args[0]))
except Exception:
if uri is not None:
log.error('Failed to upload file {0}'.format(uri))
else:
log.error('Failed to upload file')
return HttpResponseRedirect('/brew/brews/')
def brews_import(request):
uri = None
try:
if request.POST:
index = int(request.POST['index'])
file = request.FILES['file']
filename = request.FILES['file'].name
uri = os.path.dirname(os.path.realpath(__file__))
uri += '/importing/uploaded_files/'
uri += filename
fd = open(uri, 'wb')
for chunk in file.chunks():
fd.write(chunk)
fd.close()
brew_importer.BrewImporter.import_brews(index, uri)
except Exception as e:
try:
if uri is not None:
log.error('Failed to upload file {0} : {1}'.format(
uri, e.args[0]))
else:
log.error('Failed to upload file : {0}'.format(e.args[0]))
except Exception:
if uri is not None:
log.error('Failed to upload file {0}'.format(uri))
else:
log.error('Failed to upload file')
return HttpResponseRedirect('/brew/brews/')
def load_device(config, owner, simulation):
try:
device_instance = construct_class_instance(config.device_class, config)
if not issubclass(device_instance.__class__,
core.devices.device.Device):
log.error(
'Unable to load device from config: {0} is not a subclass of core.devices.device.Device'
.format(config.class_name))
return None
device_instance.owner = owner
device_instance.simulation = simulation
return device_instance
except Exception as e:
log.error('Unable to load device from config: {0}'.format(e.args[0]))
return None
def load_worker(communication_config, config):
try:
worker_instance = construct_class_instance(config.class_name, config.name)
if not issubclass(worker_instance.__class__, core.workers.baseworker.BaseWorker):
log.error('Unable to load worker from config: {0} is not a subclass of core.workers.BaseWorker'.
format(config.class_name))
return None
ip = communication_config.ip
master_port = int(communication_config.master_port)
worker_port = int(communication_config.worker_port)
worker_instance.init_communication(ip, master_port, worker_port)
worker_instance.simulation = config.simulation
worker_instance.input_config = config.inputs
worker_instance.output_config = config.outputs
return worker_instance
except Exception as e:
log.error('Unable to load worker from config: {0}'.format(e.args[0]))
return None
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 load_worker(communication_config, config):
try:
worker_instance = construct_class_instance(config.class_name,
config.name)
if not issubclass(worker_instance.__class__,
core.workers.baseworker.BaseWorker):
log.error(
'Unable to load worker from config: {0} is not a subclass of core.workers.BaseWorker'
.format(config.class_name))
return None
ip = communication_config.ip
master_port = int(communication_config.master_port)
worker_port = int(communication_config.worker_port)
worker_instance.init_communication(ip, master_port, worker_port)
worker_instance.simulation = config.simulation
worker_instance.input_config = config.inputs
worker_instance.output_config = config.outputs
return worker_instance
except Exception as e:
log.error('Unable to load worker from config: {0}'.format(e.args[0]))
return None
def deserialize_message(serialized_worker_measurement):
if serialized_worker_measurement is None:
log.error("Unable to deserialize worker measurement, serialized object is None")
if not serialized_worker_measurement.startswith(MessageMeasurement + MessageSplit):
log.error("Serialized worker measurement should begin with {0}{1}".format(MessageMeasurement, MessageSplit))
else:
try:
serialized_worker_measurement = serialized_worker_measurement[len(MessageMeasurement + MessageSplit) :]
worker_measurement_data = json.loads(serialized_worker_measurement)
worker_measurement = WorkerMeasurement()
worker_measurement.session_detail_id = worker_measurement_data["session_detail_id"]
worker_measurement.worker_name = worker_measurement_data["worker_name"]
worker_measurement.device_name = worker_measurement_data["device_name"]
worker_measurement.value = worker_measurement_data["value"]
worker_measurement.set_point = worker_measurement_data["set_point"]
worker_measurement.work = worker_measurement_data["work"]
worker_measurement.remaining = worker_measurement_data["remaining"]
if "debug_timer" in worker_measurement_data.keys():
worker_measurement.debug_timer = worker_measurement_data["debug_timer"]
else:
worker_measurement.debug_timer = None
return worker_measurement
except Exception:
log.error(
"Unable to deserialize worker measurement, serialized object is {0}".format(
serialized_worker_measurement
)
)
return None
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 handle_measurement(self, worker_measurement_data):
#log.debug('Receiving worker measurement...')
try:
with self.measurements_lock:
worker_measurement = WorkerMeasurement.deserialize_message(worker_measurement_data)
measurement = Measurement()
measurement.worker = worker_measurement.worker_name
session_detail_id = worker_measurement.session_detail_id
session_detail = SessionDetail.objects.get(pk=session_detail_id)
measurement.session_detail = session_detail
measurement.device = worker_measurement.device_name
measurement.value = worker_measurement.value
measurement.set_point = worker_measurement.set_point
measurement.work = worker_measurement.work
measurement.remaining = worker_measurement.remaining
if not worker_measurement.debug_timer is None: # In simulation mode, use fake timestamps
#measurement.timestamp = datetime.strptime(worker_measurement.debug_timer, "%Y-%m-%d %H:%M:%S.%f")
#measurement.timestamp = dt.get_current_timezone.localize(measurement.timestamp)
measurement.timestamp = worker_measurement.debug_timer
else:
measurement.timestamp = dt.now()
measurement.save()
except Exception as e:
log.error('Master could not save measurement to database ({0})'.format(e.args[0]))
def serialize_message(worker_measurement):
if worker_measurement is None:
log.error("Unable to deserialize worker measurement, object is None")
if not worker_measurement.__class__ is WorkerMeasurement:
log.error(
"Unable to serialize worker measurement, object is of type {0}".format(
worker_measurement.__class__.__name
)
)
else:
try:
if not worker_measurement.debug_timer is None:
worker_measurement.debug_timer = str(worker_measurement.debug_timer)
return MessageMeasurement + MessageSplit + json.dumps(worker_measurement.__dict__)
except Exception:
log.error("Unable to serialize worker measurement, object is {0}".format(worker_measurement))
return None
def serialize_message(worker_measurement):
if worker_measurement is None:
log.error(
'Unable to deserialize worker measurement, object is None')
if not worker_measurement.__class__ is WorkerMeasurement:
log.error(
'Unable to serialize worker measurement, object is of type {0}'
.format(worker_measurement.__class__.__name))
else:
try:
if not worker_measurement.debug_timer is None:
worker_measurement.debug_timer = str(
worker_measurement.debug_timer)
return MessageMeasurement + MessageSplit + json.dumps(
worker_measurement.__dict__)
except Exception:
log.error(
'Unable to serialize worker measurement, object is {0}'.
format(worker_measurement))
return None
def deserialize_message(serialized_worker_measurement):
if serialized_worker_measurement is None:
log.error(
'Unable to deserialize worker measurement, serialized object is None'
)
if not serialized_worker_measurement.startswith(MessageMeasurement +
MessageSplit):
log.error('Serialized worker measurement should begin with {0}{1}'.
format(MessageMeasurement, MessageSplit))
else:
try:
serialized_worker_measurement = serialized_worker_measurement[
len(MessageMeasurement + MessageSplit):]
worker_measurement_data = json.loads(
serialized_worker_measurement)
worker_measurement = WorkerMeasurement()
worker_measurement.session_detail_id = worker_measurement_data[
'session_detail_id']
worker_measurement.worker_name = worker_measurement_data[
'worker_name']
worker_measurement.device_name = worker_measurement_data[
'device_name']
worker_measurement.value = worker_measurement_data['value']
worker_measurement.set_point = worker_measurement_data[
'set_point']
worker_measurement.work = worker_measurement_data['work']
worker_measurement.remaining = worker_measurement_data[
'remaining']
if 'debug_timer' in worker_measurement_data.keys():
worker_measurement.debug_timer = worker_measurement_data[
'debug_timer']
else:
worker_measurement.debug_timer = None
return worker_measurement
except Exception:
log.error(
'Unable to deserialize worker measurement, serialized object is {0}'
.format(serialized_worker_measurement))
return None
# Construct the devices
#probe = Probe(probeconfig)
#ssr = SSR(ssrconfig)
# Fix for RasberryPi
probe = Probe()
probe.name = 'Temperature'
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')
#!/usr/bin python
from core.devices.probe import Probe
from core.devices.ssr import SSR
import core.utils.logging as log
# Fix for RasberryPi
probe = Probe()
probe.name = 'Temperature'
probe.io = 'C:\\temp\\28-00000607f0de\\w1_slave'
ssr = SSR()
ssr.name = 'Mash Tun'
ssr.io = 'C:\\temp\\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
# Do something more
def run(self):
if not self.create_device_threads():
log.error('Unable to load all devices, shutting down', True)
self.info()
self.listen()
def report_error(self, err):
log.error('{0}: {1}'.format(self.name, err), True)
def register(self):
if self.simulation:
return True
log.error("Can not register probe at \"{0}\", try to run \"sudo modprobe w1-gpio && sudo modprobe w1_therm\" in commandline or check your probe connections".format(self.io))
