READY_TIMEOUT = 10

COMMAND_REQUEST_PERIOD = 1.5

def __init__(self, usb_info, user_login):

self.logger = logging.getLogger('app.' + __name__)

self.creation_time = time.time()

self.stop_flag = False

self.usb_info = usb_info

self.user_login = user_login

self.user_token = user_login.user_token

self.printer = None

self.printer_token = None

self.error_state = "connecting"

self.last_errors = []

self.last_error = None

self.groups = []

self.printer_name = ""

self.possible_printer_types = self.get_possible_printer_types()

self.show_printer_type_selector = False

self.printer_type_selection_request = None

self.printer_type_reset_request = False

self.printer_groups_change_request = None

self.printer_rename_request = False

self.camera_update = False

self.current_camera = config.get_app().camera_controller.get_current_camera_name()

self.http_client = http_client.HTTPClient(keep_connection_flag = True, parent_usb_info = usb_info)

self.logger.info('New printer interface for %s' % str(usb_info))

super(PrinterInterface, self).__init__(name="PrinterInterface%s" % self.usb_info)

def get_possible_printer_types(self):

all_printer_profiles = self.user_login.profiles

current_printer_vid_pid = [self.usb_info['VID'], self.usb_info['PID']]

possible_types = filter(lambda profile: current_printer_vid_pid in profile['vids_pids'], all_printer_profiles)

self.logger.info("Possible printer types: " + str(possible_types))

return list(possible_types)

def request_printer_type_selection(self, printer_profile):

alias = printer_profile['alias']

self.printer_type_selection_request = alias

self.logger.info("Requesting printer type selection: " + alias)

def request_printer_groups_selection(self, groups):

self.logger.info("Groups to select: " + str(groups))

self.printer_groups_change_request = groups

def request_printer_rename(self, name):

self.logger.info("Requesting printer rename: " + str(name))

self.printer_rename_request = name

def set_printer_name(self, name):

self.printer_name = name

def get_groups(self):

return self.groups

def set_groups(self, groups):

if type(groups) == list:

self.logger.info("Groups are set correctly for %s %s" % (str(self.usb_info), str(groups)))

self.groups = groups

else:

config.create_error_report(999, "Invalid workgroups format - type must be list: " + str(groups),

self.usb_info, self.logger, is_blocking=False)

def reset_printer_type(self):

self.logger.info("Setting up flag to reset print type in next command request")

self.printer_type_reset_request = True

def connect_to_server(self): #TODO REMOVE THIS UGLY METHOD - connection must server command, like gcodes or pause

self.logger.info("Connecting to server with printer: %s" % str(self.usb_info))

while not self.stop_flag:

external_errors = self.get_my_errors()

if filter(lambda error: error['is_blocking'], external_errors):

self.stop_flag = True

return False

message = ['printer_login', self.user_token, self.usb_info]

kw_message = {}

if self.printer_type_selection_request:

kw_message['select_printer_type'] = self.printer_type_selection_request

self.logger.debug('Printer login request:\n%s\n%s ' % (str(message), str(kw_message)))

answer = self.http_client.pack_and_send(*message, **kw_message)

if answer:

error = answer.get('error')

self.printer_name = answer.get('name', '')

if error:

self.logger.warning("Error while login %s:" % str((self.user_token, self.usb_info)))

self.logger.warning(str(error['code']) + " " + error["message"])

if str(error['code']) == '8':

self.show_printer_type_selector = True

time.sleep(1)

continue

else:

config.create_error_report(26, "Server had returned error: %s" % str(error))

return False

elif answer.get('printer_profile') == "":

config.create_error_report(62, "Server return message with empty printer_profile field: %s" % str(error))

else:

groups = answer.get('current_groups', [])

self.set_groups(groups)

self.printer_type_selection_request = None

self.show_printer_type_selector = False

self.printer_rename_request = False

self.logger.info('Successfully connected to server.')

self.printer_token = answer['printer_token']

self.logger.info('Received answer: ' + str(answer))

self.printer_profile = json.loads(answer["printer_profile"])

self.logger.debug('Setting profile: ' + str(self.printer_profile))

return True

else:

self.logger.warning("Error on printer login. No connection or answer from server.")

time.sleep(0.1)

def connect_to_printer(self):

printer_sender = __import__(self.printer_profile['sender'])

self.logger.info("Connecting with profile: " + str(self.printer_profile))

try:

printer = printer_sender.Sender(self.printer_profile, self.usb_info)

except RuntimeError as e:

message = "Can't connect to printer %s %s\nReason: %s" %\

(self.printer_profile['name'], str(self.usb_info), e.message)

config.create_error_report(119, message, self.usb_info, self.logger, is_blocking=True)

except Exception as e:

message = "Unexpected error while connecting to %s: %s" % (self.printer_profile['name'], str(e))

config.create_error_report(129, message, self.usb_info, self.logger, is_blocking=True)

else:

self.logger.info("Successful connection to %s!" % (self.printer_profile['name']))

return printer

@log.log_exception

def run(self):

if self.connect_to_server():

self.printer = self.connect_to_printer()

if not self.printer:

message, kw_message, errors = self.form_command_request(None)

kw_message['error'] = errors

self.http_client.pack_and_send('command', *message, **kw_message)

time.sleep(0.1)

# even if printer is not really operational we still need to wait as if it went offline a moment ago

self.last_operational_time = time.time()

acknowledge = None

errors = None

while self.printer and self.printer.is_running or (not self.stop_flag and errors):

self.check_operational_state()

message, kw_message, errors = self.form_command_request(acknowledge)

answer = self.http_client.pack_and_send('command', *message, **kw_message)

self.logger.debug("Answer: " + str(answer))

if answer:

self.forget_sent_data(kw_message)

acknowledge = self.check_server_command(answer)

if self.stop_flag:

self.close_printer_sender()

else:

time.sleep(self.COMMAND_REQUEST_PERIOD)

self.clean_error_list()

self.logger.info('Printer interface was stopped')

def form_command_request(self, acknowledge):

errors = self.check_for_errors()

message = [self.printer_token, self.state_report(), acknowledge]

kw_message = {}

# FIXME remove copy-paste and merge logic with forget_sent_data

if self.printer_type_reset_request:

kw_message['reset_printer_type'] = self.printer_type_reset_request

self.logger.info("Adding field 'reset' to command request")

if self.printer_groups_change_request:

kw_message['selected_groups'] = self.printer_groups_change_request

self.logger.info("Adding field 'selected_groups' to command request")

if self.printer_rename_request:

kw_message['select_name'] = self.printer_rename_request

self.logger.info("Adding field 'select_name' to command request")

self.check_camera_name()

if self.camera_update:

kw_message['camera_change'] = self.camera_update

self.logger.info("Adding field 'camera_change' to command request")

if errors:

kw_message['error'] = errors

self.logger.debug("Request:\n%s\n%s" % (str(message), str(kw_message)))

return message, kw_message, errors

def forget_sent_data(self, kw_message):

keys = kw_message.keys()

if 'reset_printer_type' in keys:

self.printer_type_reset_request = False

self.stop_flag = True

self.logger.info("Got answer on command request with printer type reset field. Shutting down printer interface")

if 'selected_groups' in keys:

self.printer_groups_change_request = None

if 'select_name' in keys:

self.printer_rename_request = False

if 'camera_change' in keys:

self.camera_update = False

for error in kw_message.get('error', []):

try:

config.get_error_reports().remove(error)

except Exception as e:

self.logger.info("Can't remove error %s from errors list. Error:%s" % (str(error), str(e)))

def check_operational_state(self):

if not self.printer or self.stop_flag:

pass

elif self.printer.stop_flag:

pass

elif self.printer.is_operational(): #TODO check this operation for thread safety

self.last_operational_time = time.time()

self.error_state = None

self.last_errors = []

elif not self.error_state:

message = "Printer is not operational"

config.create_error_report(77, message, self.usb_info, self.logger, is_blocking=False)

elif self.error_state != "error" and self.last_operational_time + self.READY_TIMEOUT < time.time():

message = "Not operational timeout reached"

config.create_error_report(78, message, self.usb_info, self.logger, is_blocking=True)

def get_my_errors(self):

return list(filter(lambda error: error['usb_info'] == self.usb_info, config.get_error_reports()))

def check_for_errors(self):

errors = self.get_my_errors()

if errors:

self.logger.debug("Errors list: " + str(errors))

self.last_errors.extend(errors)

if self.last_errors:

self.last_error = self.last_errors.pop()

else:

self.last_error = None

for error in errors:

if error['is_blocking']:

self.error_state = "error"

self.close_printer_sender()

elif not self.error_state:

self.error_state = "connecting"

return errors

def clean_error_list(self):

self.logger.info('Cleaning unsent error reports')

for error in self.get_my_errors():

#this try is used for thread safety

try:

config.get_error_reports().remove(error)

except:

pass

def check_server_command(self, server_message):

if self.last_error:

if server_message.get('command'):

self.logger.error("! Server returns command on request containing an error - this is error.")

return { "number": server_message.get('number'), "result": False }

error = server_message.get('error')

if error:

self.logger.warning("@ Error in server message:%s\t%s" % (str(error['code']), error['message']))

command = server_message.get('command')

if command:

method = getattr(self.printer, command, None)

if type(server_message.get('number')) != int:

message = "Error in number field of server's message: " + str(server_message)

config.create_error_report(41, message, self.logger, is_blocking=False)

elif not method:

config.create_error_report(40, "Unknown command:'%s' " % str(command),

self.usb_info, self.logger, is_blocking=False)

else:

return self.execute_server_command(server_message)

def execute_server_command(self, server_message):

number, command, payload = server_message['number'], server_message['command'], server_message.get('payload')

self.logger.info("Executing command number %i : %s" % (number, str(command)))

method = getattr(self.printer, command)

arguments = []

if payload:

arguments.append(payload)

if server_message.get('is_link'):

arguments.append(True)

try:

result = method(*arguments)

# to reduce needless return True, we assume that when method had return None, that is success

result = result or result == None

except Exception as e:

config.create_error_report(109, "Error while executing command %s, number %d.\t%s" %

(command, number, e.message), self.usb_info, self.logger, is_blocking=False)

result = False

ack = { "number": number, "result": result }

return ack

def check_camera_name(self):

camera_name = config.get_app().camera_controller.get_current_camera_name()

if self.current_camera != camera_name:

self.logger.info("Camera change detected")

self.camera_update = camera_name

self.current_camera = camera_name

def get_printer_state(self):

if self.error_state:

state = self.error_state

elif not self.printer:

state = 'closing'

elif self.printer.is_paused():

state = "paused"

elif self.printer.is_downloading():

state = "downloading"

elif self.printer.is_printing():

state = "printing"

else:

state = "ready"

return state

def state_report(self):

report = {"state": self.get_printer_state()}

if self.printer:

try:

report["percent"] = self.printer.get_percent()

report["temps"] = self.printer.get_temps()

report["target_temps"] = self.printer.get_target_temps()

report["line_number"] = self.printer.get_current_line_number()

report["coords"] = self.printer.get_position()

except Exception as e:

self.logger.warning("@ Exception while forming printer report: " + str(e))

return report

def close_printer_sender(self):

if self.printer:

self.logger.info('Closing ' + str(self.printer_profile))

self.printer.close()

self.printer = None

self.logger.info('...closed.')

def close(self):

self.logger.info('Closing printer interface: ' + str(self.usb_info))

self.stop_flag = True