def __init__(self,
conffile,
input_fd,
startup_state,
is_fileinput=False,
version="?",
bglogger=None):
self.conffile = conffile
self.startup_state = startup_state
self.software_version = version
self.bglogger = bglogger
if bglogger is not None:
bglogger.set_rollover_info("config", None)
self.reactor = reactor.Reactor()
self.objects = {}
self.gcode = gcode.GCodeParser(self, input_fd, is_fileinput)
self.stats_timer = self.reactor.register_timer(self.stats)
self.connect_timer = self.reactor.register_timer(
self.connect, self.reactor.NOW)
self.all_config_options = {}
self.need_dump_debug = False
self.state_message = message_startup
self.debugoutput = self.dictionary = None
self.run_result = None
self.fileconfig = None
self.mcu = None
def main():
usage = "%prog [options] <serialdevice>"
opts = optparse.OptionParser(usage)
opts.add_option("-v",
action="store_true",
dest="verbose",
help="enable debug messages")
opts.add_option("-b", "--baud", type="int", dest="baud", help="baud rate")
options, args = opts.parse_args()
if len(args) != 1:
opts.error("Incorrect number of arguments")
serialport = args[0]
baud = options.baud
if baud is None and not (serialport.startswith("/dev/rpmsg_")
or serialport.startswith("/tmp/")):
baud = 250000
debuglevel = logging.INFO
if options.verbose:
debuglevel = logging.DEBUG
logging.basicConfig(level=debuglevel)
r = reactor.Reactor()
kbd = KeyboardReader(r, serialport, baud)
try:
r.run()
except KeyboardInterrupt:
sys.stdout.write("\n")
def test_reactor_read_config():
'''Validate config.yml loads config.yml properly'''
r = reactor.Reactor()
assert isinstance(r.settings, AttrDict)
# it doesn't matter what keys one puts here - the idea is to ensure
# that the config.yml is valid YAML and thus loadable as a dict
assert 'logs' in r.settings
assert r.settings.logs.level == 'DEBUG'
def units_init():
reactor = r.Reactor(initial_dbo, Q)
alagoon = al.ALagoon(initial_dbo, Q)
alagoon_tr = al_tr.ALagoon_tr(initial_dbo, Q)
#alagoon_vincent = al_vincent.ALagoon_vincent(initial_dbo,Q)
unit_list = [reactor, alagoon, alagoon_tr]
return unit_list
def __init__(self,
torrent_path,
directory='',
port=55308,
download_all=False,
visualizer=None):
torrent_dict = tparser.bdecode_file(torrent_path)
self.torrent_dict = torrent_dict
self.peer_dict = {}
self.peer_ips = []
self.port = port
self.download_all = download_all
self.r = None
self.tracker_response = None
self.peer_dict = {}
self.hash_string = None
self.queued_requests = []
self.vis_write_sock = ''
self.reactor = reactor.Reactor()
self.reactor.add_listeners([
PeerListener(torrent=self, port=7000),
VisListener(torrent=self, port=8035)
])
# Try to connect to visualization server
vis_socket = connect_vis(visualizer) if visualizer else None
if directory:
os.chdir(directory)
if 'files' in self.torrent_dict['info']:
dirname = self.torrent_dict['info']['name']
else:
dirname = None
file_list = []
# Multifile case
if 'files' in self.torrent_dict['info']:
file_list.extend(self.torrent_dict['info']['files'])
multifile = True
# Deal with single-file torrents by building up the kind of dict
# found in torrent_dict['info']['files']
elif 'name' in self.torrent_dict['info']:
info_dict = {}
info_dict['path'] = self.torrent_dict['info']['name']
info_dict['length'] = self.torrent_dict['info']['length']
file_list.append(info_dict)
multifile = False
else:
raise Exception('Invalid .torrent file')
self.switchboard = Switchboard(dirname=dirname,
file_list=file_list,
piece_length=self.piece_length,
num_pieces=self.num_pieces,
multifile=multifile,
download_all=download_all,
vis_socket=vis_socket)
def __init__(self, input_fd, bglogger, start_args):
self.bglogger = bglogger
self.start_args = start_args
self.reactor = reactor.Reactor()
self.reactor.register_callback(self._connect)
self.state_message = message_startup
self.is_shutdown = False
self.run_result = None
self.event_handlers = {}
gc = gcode.GCodeParser(self, input_fd)
self.objects = collections.OrderedDict({'gcode': gc})
def __init__(self, input_fd, bglogger, start_args):
self.bglogger = bglogger
self.start_args = start_args
self.reactor = reactor.Reactor()
self.reactor.register_callback(self._connect)
self.state_message = message_startup
self.in_shutdown_state = False
self.run_result = None
self.event_handlers = {}
self.objects = collections.OrderedDict()
self.objects['webhooks'] = webhooks.WebHooks(self)
self.objects['gcode'] = gcode.GCodeParser(self, input_fd)
def __init__(self, bglogger, start_args):
self.bglogger = bglogger
self.start_args = start_args
self.reactor = reactor.Reactor()
self.reactor.register_callback(self._connect)
self.state_message = message_startup
self.in_shutdown_state = False
self.run_result = None
self.event_handlers = {}
self.objects = collections.OrderedDict()
# Init printer components that must be setup prior to config
for m in [gcode, webhooks]:
m.add_early_printer_objects(self)
def __init__(self, input_fd, bglogger, start_args):
self.bglogger = bglogger
self.start_args = start_args
self.reactor = reactor.Reactor()
gc = gcode.GCodeParser(self, input_fd)
self.objects = collections.OrderedDict({'gcode': gc})
self.stats_timer = self.reactor.register_timer(self._stats)
self.connect_timer = self.reactor.register_timer(
self._connect, self.reactor.NOW)
self.state_message = message_startup
self.is_shutdown = False
self.async_shutdown_msg = ""
self.run_result = None
self.stats_cb = []
self.state_cb = []
def main():
usage = "%prog [options] <serialdevice> <baud>"
opts = optparse.OptionParser(usage)
options, args = opts.parse_args()
serialport, baud = args
baud = int(baud)
logging.basicConfig(level=logging.DEBUG)
r = reactor.Reactor()
ser = serialhdl.SerialReader(r, serialport, baud)
kbd = KeyboardReader(ser, r)
try:
r.run()
except KeyboardInterrupt:
sys.stdout.write("\n")
def start_process(config, init_func, module_name, mp_queues):
# Avoid active imports changing environment - import in target process
mod = importlib.import_module('parallel_extras.' + module_name)
init_func = getattr(mod, init_func, None)
config.reactor = reactor.Reactor(process=module_name)
def start(e):
config.reactor.setup_mp_queues(mp_queues)
config.reactor.root = init_func(config)
try:
config.reactor.register_callback(start)
config.reactor.run()
except Exception:
logging.getLogger(module_name).exception(
"Unhandled exception during run")
def __init__(self, input_fd, bglogger, start_args):
self.bglogger = bglogger
self.start_args = start_args
if bglogger is not None:
bglogger.set_rollover_info("config", None)
self.reactor = reactor.Reactor()
self.objects = {}
self.gcode = gcode.GCodeParser(self, input_fd)
self.stats_timer = self.reactor.register_timer(self._stats)
self.connect_timer = self.reactor.register_timer(
self._connect, self.reactor.NOW)
self.all_config_options = {}
self.need_dump_debug = False
self.state_message = message_startup
self.run_result = None
self.fileconfig = None
self.mcu = None
def run_reactor_task(self, run_cb):
self.task_complete = False
k_reactor = reactor.Reactor()
self.mcu_conn = MCUConnection(k_reactor, self.device_path,
self.baud_rate, self.board_config)
k_reactor.register_callback(run_cb)
try:
k_reactor.run()
except SPIFlashError:
raise
except Exception:
# ignore exceptions that occur after a task is complete
if not self.task_complete:
raise
finally:
self.mcu_conn.disconnect()
k_reactor.finalize()
self.mcu_conn = k_reactor = None
def __init__(self, input_fd, bglogger, start_args):
self.bglogger = bglogger
self.start_args = start_args
if bglogger is not None:
bglogger.set_rollover_info("config", None)
self.reactor = reactor.Reactor()
gc = gcode.GCodeParser(self, input_fd)
self.objects = collections.OrderedDict({'gcode': gc})
self.stats_timer = self.reactor.register_timer(self._stats)
self.connect_timer = self.reactor.register_timer(
self._connect, self.reactor.NOW)
self.all_config_options = {}
self.state_message = message_startup
self.is_shutdown = False
self.async_shutdown_msg = ""
self.run_result = None
self.fileconfig = None
self.stats_cb = []
self.state_cb = []
def onReady(self):
try:
self.options = Soph.defaultOpts
with open("options.json", "r", encoding="utf-8") as f:
opts = json.loads(f.read(), encoding="utf-8")
self.options.update(opts)
except Exception as e:
self.log("Crap: {0}".format(e))
return
self.greeting = self.options.get("greeting", "I'm ready")
self.optTime = time.time()
self.loadUsers()
self.loadAliases()
self.loadTz()
task = self.loadAllUsers()
fut = asyncio.ensure_future(task)
async def check_deps():
try:
resp = await wsClient.call(8888, "ping", "")
print("index already up")
except:
print("index isn't up")
kwargs = {}
#if platform.system() == 'Windows':
# from msdn [1]
#CREATE_NEW_PROCESS_GROUP = 0x00000200 # note: could get it from subprocess
#DETACHED_PROCESS = 0x00000008 # 0x8 | 0x200 == 0x208
#kwargs.update(creationflags=DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP)
sp = subprocess.Popen(["python", "indexBundle.py"],
start_new_session=True,
shell=True,
stdin=None,
stdout=None,
stderr=None,
close_fds=True,
**kwargs)
self.childProcs.append(sp)
task = check_deps()
fut = asyncio.ensure_future(task)
self.addressPat = re.compile(r"^(Ok|So)((,\s*)|(\s+))" +
self.options["name"] + r"\s*[,-\.:]\s*")
for server in self.client.servers or {}:
self.serverMap[server.name] = server.id
if "servers" in self.options:
for server_opts in self.options["servers"]:
try:
id = server_opts["id"]
except:
name = server_opts.get("name")
id = self.serverMap[name]
self.serverOpts[id] = server_opts
for k, o in self.serverOpts.items():
regs = o.get("infoRegs", [])
o["infoRegs"] = [re.compile(r) for r in regs]
self.reactor = reactor.Reactor(self.serverOpts)
self.greeters = utils.SophDefaultDict(lambda x: greeter.Greeter(
self.serverOpts.get(x, {}).get("greetings", [])))
self.ready = True
def main():
usage = "%prog [options] <config file>"
opts = optparse.OptionParser(usage)
opts.add_option("-i",
"--debuginput",
dest="debuginput",
help="read commands from file instead of from tty port")
opts.add_option("-I",
"--input-tty",
dest="inputtty",
default='/tmp/printer',
help="input tty name (default is /tmp/printer)")
opts.add_option("-a",
"--api-server",
dest="apiserver",
help="api server unix domain socket filename")
opts.add_option("-l",
"--logfile",
dest="logfile",
help="write log to file instead of stderr")
opts.add_option("-v",
action="store_true",
dest="verbose",
help="enable debug messages")
opts.add_option("-o",
"--debugoutput",
dest="debugoutput",
help="write output to file instead of to serial port")
opts.add_option("-d",
"--dictionary",
dest="dictionary",
type="string",
action="callback",
callback=arg_dictionary,
help="file to read for mcu protocol dictionary")
options, args = opts.parse_args()
if len(args) != 1:
opts.error("Incorrect number of arguments")
start_args = {
'config_file': args[0],
'apiserver': options.apiserver,
'start_reason': 'startup'
}
debuglevel = logging.INFO
if options.verbose:
debuglevel = logging.DEBUG
start_args['debuglevel'] = debuglevel
if options.debuginput:
start_args['debuginput'] = options.debuginput
debuginput = open(options.debuginput, 'rb')
start_args['gcode_fd'] = debuginput.fileno()
else:
start_args['gcode_fd'] = util.create_pty(options.inputtty)
if options.debugoutput:
start_args['debugoutput'] = options.debugoutput
start_args.update(options.dictionary)
bglogger = None
if options.logfile:
start_args['log_file'] = options.logfile
bglogger = queuelogger.setup_bg_logging(options.logfile, debuglevel)
else:
logging.basicConfig(level=debuglevel)
logging.info("Starting Klippy...")
start_args['software_version'] = util.get_git_version()
start_args['cpu_info'] = util.get_cpu_info()
if bglogger is not None:
versions = "\n".join([
"Args: %s" % (sys.argv, ),
"Git version: %s" % (repr(start_args['software_version']), ),
"CPU: %s" % (start_args['cpu_info'], ),
"Python: %s" % (repr(sys.version), )
])
logging.info(versions)
elif not options.debugoutput:
logging.warning("No log file specified!"
" Severe timing issues may result!")
gc.disable()
# Start Printer() class
while 1:
if bglogger is not None:
bglogger.clear_rollover_info()
bglogger.set_rollover_info('versions', versions)
gc.collect()
main_reactor = reactor.Reactor(gc_checking=True)
printer = Printer(main_reactor, bglogger, start_args)
res = printer.run()
if res in ['exit', 'error_exit']:
break
time.sleep(1.)
main_reactor.finalize()
main_reactor = printer = None
logging.info("Restarting printer")
start_args['start_reason'] = res
if bglogger is not None:
bglogger.stop()
if res == 'error_exit':
sys.exit(-1)
def test_reactor_init():
'''Ensure Reactor object can initialize'''
r = reactor.Reactor()
assert isinstance(r, Reactor)
def main():
r = reactor.Reactor()
r.start_watch()
def main():
r = reactor.Reactor()
