def __init__(self, stack, handler):
super(IControlTask, self).__init__(stack, handler)
self.handler = proxy(handler)
self.handler.binary_mode = True
self.cmd_queue = deque()
self.meta = Metadata.instance()
self._ready = 0
def on_mainboard_ready(ctrl):
self._ready |= 1
self.mainboard.send_cmd("X8F")
self.mainboard.send_cmd("T0")
self.mainboard.send_cmd("G90")
self.mainboard.send_cmd("G92E0")
handler.send_text("ok")
self.mainboard = MainController(
self._sock_mb.fileno(),
bufsize=14,
empty_callback=self.on_mainboard_empty,
sendable_callback=self.on_mainboard_sendable,
ctrl_callback=self.on_mainboard_result)
self.toolhead = HeadController(
self._sock_th.fileno(),
msg_callback=self.toolhead_message_callback)
self.mainboard.bootstrap(on_mainboard_ready)
self.unpacker = Unpacker()
def __init__(self, options):
super(NetworkService, self).__init__(logger)
self.cm = Metadata()
self.activated = (self.cm.wifi_status & 1 == 0)
self.nic_status = {}
self.daemons = {}
self.timer_watcher = self.loop.timer(0, 5, self.on_timer, (5, None))
self.timer_watcher.start()
def __init__(self, kernel, endpoint=None, handler=None):
self.kernel = proxy(kernel)
self.handler = handler
self.meta = Metadata()
s = self.create_socket(endpoint)
self.listen_w = kernel.loop.io(s, pyev.EV_READ, self.on_accept, s)
self.listen_w.start()
self.timer_w = kernel.loop.timer(30, 30, self.on_timer)
self.timer_w.start()
self.clients = WeakSet()
def create_raven_logger(dsn):
try:
import fluxmonitor
from fluxmonitor.storage import Metadata
m = Metadata()
import raven # noqa
return {
'level': 'ERROR',
'class': 'raven.handlers.logging.SentryHandler',
'machine': m.nickname.decode("utf8", "ignore"),
'release': fluxmonitor.__version__,
'dsn': dsn
}
except ImportError:
sys.stderr.write("Can not configure raven logger\n")
sys.stderr.flush()
def __init__(self, options):
# Create RSA key if not exist. This will prevent upnp create key during
# upnp is running (Its takes times and will cause timeout)
self.master_key = security.get_private_key()
self.slave_pkey = security.RSAObject(keylength=1024)
self.meta = Metadata.instance()
self.meta.shared_der_rsakey = self.slave_pkey.export_der()
self.meta.update_device_status(0, 0, "OFFLINE", "")
ServiceBase.__init__(self, logger, options)
self.upnp_tcp = UpnpTcpInterface(self)
self.nw_monitor = NetworkMonitor()
self.nw_monitor_watcher = self.loop.io(self.nw_monitor, pyev.EV_READ,
self.on_network_changed)
self.nw_monitor_watcher.start()
self.cron_watcher = self.loop.timer(3.0, 3.0, self.on_cron)
self.cron_watcher.start()
def __init__(self, kernel):
super(UartHal, self).__init__(kernel)
self.meta = Metadata.instance()
GPIOUtils.setup()
def try_config_network(dryrun=False):
anti_garbage_usb_mass_storage()
if os.path.exists("/media/usb/config_flux.txt"):
print("USB Disk found")
from ConfigParser import RawConfigParser
from fluxmonitor.security import get_serial
from fluxmonitor.storage import Storage
from hashlib import md5
storage = Storage("general", "meta")
with open("/media/usb/config_flux.txt") as f:
h = md5(f.read()).hexdigest()
print("Fingerprint local=%s, disk=%s" %
(storage["flashconfig_history"], h))
if storage["flashconfig_history"] == h:
print("This config file is already done, ignore")
return
c = RawConfigParser()
c.read("/media/usb/config_flux.txt")
if "device" in c.sections():
device = dict(c.items("device"))
s = device.get("serial")
if s and get_serial() != s:
print("Device serial not match")
return
else:
print("Device section not found, ignore")
if "general" in c.sections():
general_config = dict(c.items("general"))
name = general_config.get("name")
if name:
if dryrun:
print("[Dryrun] Config name to: %s" % name)
else:
from fluxmonitor.storage import Metadata
m = Metadata()
m.nickname = general_config["name"]
password = general_config.get("password")
if password:
if dryrun:
print("[Dryrun] Set password to: ***")
else:
from fluxmonitor.security import set_password
set_password(general_config["password"])
if "network" in c.sections():
network_config = dict(c.items("network"))
if dryrun:
print("[Dryrun] Config network: %s" % network_config)
else:
from fluxmonitor.misc import network_config_encoder as NCE # noqa
from fluxmonitor.config import NETWORK_MANAGE_ENDPOINT
import socket
s = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM)
s.connect(NETWORK_MANAGE_ENDPOINT)
s.send(b"%s\x00%s" %
(b"config_network", NCE.to_bytes(network_config)))
storage["flashconfig_history"] = h
def setUp(self):
self.meta = Metadata()
self.reset_callback()
self.meta.plate_correction = {"X": 0, "Y": 0, "Z": 0, "H": 242}
self.cm = CorrectionMacro(self.on_success_callback)
def delay_toolhead_poweroff():
from fluxmonitor.storage import Metadata
Metadata.instance().delay_toolhead_poweroff = b"\x01"