def check_connection():
"""
Check for network connection. If not paired trigger pairing.
Runs as a Timer every second until connection is detected.
"""
if connected():
enclosure = EnclosureAPI(ws)
if is_paired():
# Skip the sync message when unpaired because the prompt to go to
# home.mycrof.ai will be displayed by the pairing skill
enclosure.mouth_text(mycroft.dialog.get("message_synching.clock"))
# Force a sync of the local clock with the internet
ws.emit(Message("system.ntp.sync"))
time.sleep(15) # TODO: Generate/listen for a message response...
# Check if the time skewed significantly. If so, reboot
skew = abs((monotonic.monotonic() - start_ticks) -
(time.time() - start_clock))
if skew > 60 * 60:
# Time moved by over an hour in the NTP sync. Force a reboot to
# prevent weird things from occcurring due to the 'time warp'.
#
ws.emit(
Message(
"speak",
{'utterance': mycroft.dialog.get("time.changed.reboot")}))
wait_while_speaking()
# provide visual indicators of the reboot
enclosure.mouth_text(mycroft.dialog.get("message_rebooting"))
enclosure.eyes_color(70, 65, 69) # soft gray
enclosure.eyes_spin()
# give the system time to finish processing enclosure messages
time.sleep(1.0)
# reboot
ws.emit(Message("system.reboot"))
return
else:
ws.emit(Message("enclosure.mouth.reset"))
time.sleep(0.5)
ws.emit(Message('mycroft.internet.connected'))
# check for pairing, if not automatically start pairing
if not is_paired():
# begin the process
payload = {'utterances': ["pair my device"], 'lang': "en-us"}
ws.emit(Message("recognizer_loop:utterance", payload))
else:
from mycroft.api import DeviceApi
api = DeviceApi()
api.update_version()
else:
thread = Timer(1, check_connection)
thread.daemon = True
thread.start()
class WiFi:
def __init__(self):
self.iface = pyw.winterfaces()[0]
self.ap = AccessPoint(self.iface)
self.server = None
self.ws = WebsocketClient()
ConfigurationManager.init(self.ws)
self.enclosure = EnclosureAPI(self.ws)
self.init_events()
self.conn_monitor = None
self.conn_monitor_stop = threading.Event()
def init_events(self):
'''
Register handlers for various websocket events used
to communicate with outside systems.
'''
# This event is generated by an outside mechanism. On a
# Holmes unit this comes from the Enclosure's menu item
# being selected.
self.ws.on('mycroft.wifi.start', self.start)
# These events are generated by Javascript in the captive
# portal.
self.ws.on('mycroft.wifi.stop', self.stop)
self.ws.on('mycroft.wifi.scan', self.scan)
self.ws.on('mycroft.wifi.connect', self.connect)
def start(self, event=None):
'''
Fire up the MYCROFT access point for the user to connect to
with a phone or computer.
'''
LOG.info("Starting access point...")
# Fire up our access point
self.ap.up()
LOG.info("Done putting ap up...")
if not self.server:
LOG.info("Creating web server...")
self.server = WebServer(self.ap.ip, 80)
LOG.info("Starting web server...")
self.server.start()
LOG.info("Created web server.")
LOG.info("Access point started!\n%s" % self.ap.__dict__)
self._start_connection_monitor()
def _connection_prompt(self, prefix):
# let the user know to connect to it...
passwordSpelled = ", ".join(self.ap.password)
self._speak_and_show(
prefix + " Use your mobile device or computer to "
"connect to the wifi network "
"'MYCROFT'; Then enter the uppercase "
"password " + passwordSpelled,
self.ap.password)
def _speak_and_show(self, speak, show):
''' Communicate with the user throughout the process '''
self.ws.emit(Message("speak", {'utterance': speak}))
if show is None:
return
# TODO: This sleep should not be necessary, but without it the
# text to be displayed by enclosure.mouth_text() gets
# wiped out immediately when the utterance above is
# begins processing.
# Remove the sleep once this behavior is corrected.
sleep(0.25)
self.enclosure.mouth_text(show)
def _start_connection_monitor(self):
LOG.info("Starting monitor thread...\n")
if self.conn_monitor is not None:
LOG.info("Killing old thread...\n")
self.conn_monitor_stop.set()
self.conn_monitor_stop.wait()
self.conn_monitor = threading.Thread(
target=self._do_connection_monitor,
args={})
self.conn_monitor.daemon = True
self.conn_monitor.start()
LOG.info("Monitor thread setup complete.\n")
def _stop_connection_monitor(self):
''' Set flag that will let monitoring thread close '''
self.conn_monitor_stop.set()
def _do_connection_monitor(self):
LOG.info("Invoked monitor thread...\n")
mtimeLast = os.path.getmtime('/var/lib/misc/dnsmasq.leases')
bHasConnected = False
cARPFailures = 0
timeStarted = time.time()
timeLastAnnounced = 0 # force first announcement to now
self.conn_monitor_stop.clear()
while not self.conn_monitor_stop.isSet():
# do our monitoring...
mtime = os.path.getmtime('/var/lib/misc/dnsmasq.leases')
if mtimeLast != mtime:
# Something changed in the dnsmasq lease file -
# presumably a (re)new lease
bHasConnected = True
cARPFailures = 0
mtimeLast = mtime
timeStarted = time.time() # reset start time after connection
timeLastAnnounced = time.time() - 45 # announce how to connect
if time.time() - timeStarted > 60 * 5:
# After 5 minutes, shut down the access point
LOG.info("Auto-shutdown of access point after 5 minutes")
self.stop()
continue
if time.time() - timeLastAnnounced >= 45:
if bHasConnected:
self._speak_and_show(
"Now you can open your browser and go to start dot "
"mycroft dot A I, then follow the instructions given "
" there",
"start.mycroft.ai")
else:
self._connection_prompt("Allow me to walk you through the "
" wifi setup process; ")
timeLastAnnounced = time.time()
if bHasConnected:
# Flush the ARP entries associated with our access point
# This will require all network hardware to re-register
# with the ARP tables if still present.
if cARPFailures == 0:
res = cli_no_output('ip', '-s', '-s', 'neigh', 'flush',
self.ap.subnet + '.0/24')
# Give ARP system time to re-register hardware
sleep(5)
# now look at the hardware that has responded, if no entry
# shows up on our access point after 2*5=10 seconds, the user
# has disconnected
if not self._is_ARP_filled():
cARPFailures += 1
if cARPFailures > 2:
self._connection_prompt("Connection lost,")
bHasConnected = False
else:
cARPFailures = 0
sleep(5) # wait a bit to prevent thread from hogging CPU
LOG.info("Exiting monitor thread...\n")
self.conn_monitor_stop.clear()
def _is_ARP_filled(self):
res = cli_no_output('/usr/sbin/arp', '-n')
out = str(res.get("stdout"))
if out:
# Parse output, skipping header
for o in out.split("\n")[1:]:
if o[0:len(self.ap.subnet)] == self.ap.subnet:
if "(incomplete)" in o:
# ping the IP to get the ARP table entry reloaded
ip_disconnected = o.split(" ")[0]
cli_no_output('/bin/ping', '-c', '1', '-W', '3',
ip_disconnected)
else:
return True # something on subnet is connected!
return False
def scan(self, event=None):
LOG.info("Scanning wifi connections...")
networks = {}
status = self.get_status()
for cell in Cell.all(self.iface):
update = True
ssid = cell.ssid
quality = self.get_quality(cell.quality)
# If there are duplicate network IDs (e.g. repeaters) only
# report the strongest signal
if networks.__contains__(ssid):
update = networks.get(ssid).get("quality") < quality
if update and ssid:
networks[ssid] = {
'quality': quality,
'encrypted': cell.encrypted,
'connected': self.is_connected(ssid, status)
}
self.ws.emit(Message("mycroft.wifi.scanned",
{'networks': networks}))
LOG.info("Wifi connections scanned!\n%s" % networks)
@staticmethod
def get_quality(quality):
values = quality.split("/")
return float(values[0]) / float(values[1])
def connect(self, event=None):
if event and event.data:
ssid = event.data.get("ssid")
connected = self.is_connected(ssid)
if connected:
LOG.warn("Mycroft is already connected to %s" % ssid)
else:
self.disconnect()
LOG.info("Connecting to: %s" % ssid)
nid = wpa(self.iface, 'add_network')
wpa(self.iface, 'set_network', nid, 'ssid', '"' + ssid + '"')
if event.data.__contains__("pass"):
psk = '"' + event.data.get("pass") + '"'
wpa(self.iface, 'set_network', nid, 'psk', psk)
else:
wpa(self.iface, 'set_network', nid, 'key_mgmt', 'NONE')
wpa(self.iface, 'enable', nid)
connected = self.get_connected(ssid)
if connected:
wpa(self.iface, 'save_config')
self.ws.emit(Message("mycroft.wifi.connected",
{'connected': connected}))
LOG.info("Connection status for %s = %s" % (ssid, connected))
if connected:
self.ws.emit(Message("speak", {
'utterance': "Thank you, I'm now connected to the "
"internet and ready for use"}))
# TODO: emit something that triggers a pairing check
def disconnect(self):
status = self.get_status()
nid = status.get("id")
if nid:
ssid = status.get("ssid")
wpa(self.iface, 'disable', nid)
LOG.info("Disconnecting %s id: %s" % (ssid, nid))
def get_status(self):
res = cli('wpa_cli', '-i', self.iface, 'status')
out = str(res.get("stdout"))
if out:
return dict(o.split("=") for o in out.split("\n")[:-1])
return {}
def get_connected(self, ssid, retry=5):
connected = self.is_connected(ssid)
while not connected and retry > 0:
sleep(2)
retry -= 1
connected = self.is_connected(ssid)
return connected
def is_connected(self, ssid, status=None):
status = status or self.get_status()
state = status.get("wpa_state")
return status.get("ssid") == ssid and state == "COMPLETED"
def stop(self, event=None):
LOG.info("Stopping access point...")
self._stop_connection_monitor()
self.ap.down()
if self.server:
self.server.server.shutdown()
self.server.server.server_close()
self.server.join()
self.server = None
LOG.info("Access point stopped!")
def _do_net_check(self):
# give system 5 seconds to resolve network or get plugged in
sleep(5)
LOG.info("Checking internet connection again")
if not connected() and self.conn_monitor is None:
# TODO: Enclosure/localization
self._speak_and_show(
"This device is not connected to the Internet. Either plug "
"in a network cable or hold the button on top for two "
"seconds, then select wifi from the menu", None)
def run(self):
try:
# When the system first boots up, check for a valid internet
# connection.
LOG.info("Checking internet connection")
if not connected():
LOG.info("No connection initially, waiting 20...")
self.net_check = threading.Thread(
target=self._do_net_check,
args={})
self.net_check.daemon = True
self.net_check.start()
else:
LOG.info("Connection found!")
self.ws.run_forever()
except Exception as e:
LOG.error("Error: {0}".format(e))
self.stop()
class WiFi:
NAME = "WiFiClient"
def __init__(self):
self.iface = pyw.winterfaces()[0]
self.ap = AccessPoint(self.iface)
self.server = None
self.client = WebsocketClient()
self.enclosure = EnclosureAPI(self.client)
self.config = ConfigurationManager.get().get(self.NAME)
self.init_events()
self.first_setup()
def init_events(self):
self.client.on('mycroft.wifi.start', self.start)
self.client.on('mycroft.wifi.stop', self.stop)
self.client.on('mycroft.wifi.scan', self.scan)
self.client.on('mycroft.wifi.connect', self.connect)
def first_setup(self):
if str2bool(self.config.get('setup')):
self.start()
def start(self, event=None):
LOG.info("Starting access point...")
self.client.emit(
Message(
"speak",
metadata={'utterance': "Initializing wireless setup mode."}))
self.ap.up()
if not self.server:
self.server = WebServer(self.ap.ip, 80)
self.server.start()
self.enclosure.mouth_text(self.ap.password)
LOG.info("Access point started!\n%s" % self.ap.__dict__)
def scan(self, event=None):
LOG.info("Scanning wifi connections...")
networks = {}
status = self.get_status()
for cell in Cell.all(self.iface):
update = True
ssid = cell.ssid
quality = self.get_quality(cell.quality)
if networks.__contains__(ssid):
update = networks.get(ssid).get("quality") < quality
if update and ssid:
networks[ssid] = {
'quality': quality,
'encrypted': cell.encrypted,
'connected': self.is_connected(ssid, status)
}
self.client.emit(
Message("mycroft.wifi.scanned", {'networks': networks}))
LOG.info("Wifi connections scanned!\n%s" % networks)
@staticmethod
def get_quality(quality):
values = quality.split("/")
return float(values[0]) / float(values[1])
def connect(self, event=None):
if event and event.metadata:
ssid = event.metadata.get("ssid")
connected = self.is_connected(ssid)
if connected:
LOG.warn("Mycroft is already connected to %s" % ssid)
else:
self.disconnect()
LOG.info("Connecting to: %s" % ssid)
nid = wpa(self.iface, 'add_network')
wpa(self.iface, 'set_network', nid, 'ssid', '"' + ssid + '"')
if event.metadata.__contains__("pass"):
psk = '"' + event.metadata.get("pass") + '"'
wpa(self.iface, 'set_network', nid, 'psk', psk)
else:
wpa(self.iface, 'set_network', nid, 'key_mgmt', 'NONE')
wpa(self.iface, 'enable', nid)
connected = self.get_connected(ssid)
if connected:
wpa(self.iface, 'save_config')
ConfigurationManager.set(self.NAME, 'setup', False, True)
self.client.emit(
Message("mycroft.wifi.connected", {'connected': connected}))
LOG.info("Connection status for %s = %s" % (ssid, connected))
def disconnect(self):
status = self.get_status()
nid = status.get("id")
if nid:
ssid = status.get("ssid")
wpa(self.iface, 'disable', nid)
LOG.info("Disconnecting %s id: %s" % (ssid, nid))
def get_status(self):
res = cli('wpa_cli', '-i', self.iface, 'status')
out = str(res.get("stdout"))
if out:
return dict(o.split("=") for o in out.split("\n")[:-1])
return {}
def get_connected(self, ssid, retry=5):
connected = self.is_connected(ssid)
while not connected and retry > 0:
sleep(2)
retry -= 1
connected = self.is_connected(ssid)
return connected
def is_connected(self, ssid, status=None):
status = status or self.get_status()
state = status.get("wpa_state")
return status.get("ssid") == ssid and state == "COMPLETED"
def stop(self, event=None):
LOG.info("Stopping access point...")
self.ap.down()
if self.server:
self.server.server.shutdown()
self.server.server.server_close()
self.server.join()
self.server = None
LOG.info("Access point stopped!")
def run(self):
try:
self.client.run_forever()
except Exception as e:
LOG.error("Error: {0}".format(e))
self.stop()
class SkillManager(Thread):
""" Load, update and manage instances of Skill on this system. """
def __init__(self, ws):
super(SkillManager, self).__init__()
self._stop_event = Event()
self._loaded_priority = Event()
self.loaded_skills = {}
self.msm_blocked = False
self.ws = ws
self.enclosure = EnclosureAPI(ws)
# Schedule install/update of default skill
self.next_download = None
# Conversation management
ws.on('skill.converse.request', self.handle_converse_request)
# Update on initial connection
ws.on('mycroft.internet.connected', self.schedule_update_skills)
# Update upon request
ws.on('skillmanager.update', self.schedule_now)
ws.on('skillmanager.list', self.send_skill_list)
# Register handlers for external MSM signals
ws.on('msm.updating', self.block_msm)
ws.on('msm.removing', self.block_msm)
ws.on('msm.installing', self.block_msm)
ws.on('msm.updated', self.restore_msm)
ws.on('msm.removed', self.restore_msm)
ws.on('msm.installed', self.restore_msm)
# when locked, MSM is active or intentionally blocked
self.__msm_lock = Lock()
self.__ext_lock = Lock()
def schedule_update_skills(self, message=None):
""" Schedule a skill update to take place directly. """
if direct_update_needed():
# Update skills at next opportunity
LOG.info('Skills will be updated directly')
self.schedule_now()
# Skip the message when unpaired because the prompt to go
# to home.mycrof.ai will be displayed by the pairing skill
if not is_paired():
self.enclosure.mouth_text(dialog.get("message_updating"))
else:
LOG.info('Skills will be updated at a later time')
self.next_download = time.time() + 60 * MINUTES
def schedule_now(self, message=None):
self.next_download = time.time() - 1
def block_msm(self, message=None):
""" Disallow start of msm. """
# Make sure the external locking of __msm_lock is done in correct order
with self.__ext_lock:
if not self.msm_blocked:
self.__msm_lock.acquire()
self.msm_blocked = True
def restore_msm(self, message=None):
""" Allow start of msm if not allowed. """
# Make sure the external locking of __msm_lock is done in correct order
with self.__ext_lock:
if self.msm_blocked:
self.__msm_lock.release()
self.msm_blocked = False
def download_skills(self, speak=False):
""" Invoke MSM to install default skills and/or update installed skills
Args:
speak (bool, optional): Speak the result? Defaults to False
"""
# Don't invoke msm if already running
if exists(MSM_BIN) and self.__msm_lock.acquire():
try:
# Invoke the MSM script to do the hard work.
LOG.debug("==== Invoking Mycroft Skill Manager: " + MSM_BIN)
p = subprocess.Popen(MSM_BIN + " default",
stderr=subprocess.STDOUT,
stdout=subprocess.PIPE,
shell=True)
(output, err) = p.communicate()
res = p.returncode
# Always set next update to an hour from now if successful
if res == 0:
self.next_download = time.time() + 60 * MINUTES
if res == 0 and speak:
data = {'utterance': dialog.get("skills updated")}
self.ws.emit(Message("speak", data))
return True
elif not connected():
LOG.error('msm failed, network connection not available')
if speak:
self.ws.emit(
Message(
"speak", {
'utterance':
dialog.get("not connected to the internet")
}))
self.next_download = time.time() + 5 * MINUTES
return False
elif res != 0:
LOG.error('msm failed with error {}: {}'.format(
res, output))
if speak:
self.ws.emit(
Message(
"speak", {
'utterance':
dialog.get(
"sorry I couldn't install default skills"
)
}))
self.next_download = time.time() + 5 * MINUTES
return False
finally:
self.__msm_lock.release()
else:
LOG.error("Unable to invoke Mycroft Skill Manager: " + MSM_BIN)
def _load_or_reload_skill(self, skill_folder):
"""
Check if unloaded skill or changed skill needs reloading
and perform loading if necessary.
Returns True if the skill was loaded/reloaded
"""
if skill_folder not in self.loaded_skills:
self.loaded_skills[skill_folder] = {
"id": hash(os.path.join(SKILLS_DIR, skill_folder))
}
skill = self.loaded_skills.get(skill_folder)
skill["path"] = os.path.join(SKILLS_DIR, skill_folder)
# check if folder is a skill (must have __init__.py)
if not MainModule + ".py" in os.listdir(skill["path"]):
return False
# getting the newest modified date of skill
modified = _get_last_modified_date(skill["path"])
last_mod = skill.get("last_modified", 0)
# checking if skill is loaded and hasn't been modified on disk
if skill.get("loaded") and modified <= last_mod:
return False # Nothing to do!
# check if skill was modified
elif skill.get("instance") and modified > last_mod:
# check if skill has been blocked from reloading
if not skill["instance"].reload_skill:
return False
LOG.debug("Reloading Skill: " + skill_folder)
# removing listeners and stopping threads
try:
skill["instance"]._shutdown()
except Exception:
LOG.exception("An error occured while shutting down {}".format(
skill["instance"].name))
if DEBUG:
gc.collect() # Collect garbage to remove false references
# Remove two local references that are known
refs = sys.getrefcount(skill["instance"]) - 2
if refs > 0:
msg = ("After shutdown of {} there are still "
"{} references remaining. The skill "
"won't be cleaned from memory.")
LOG.warning(msg.format(skill['instance'].name, refs))
del skill["instance"]
self.ws.emit(
Message("mycroft.skills.shutdown", {
"folder": skill_folder,
"id": skill["id"]
}))
# (Re)load the skill from disk
with self.__msm_lock: # Make sure msm isn't running
skill["loaded"] = True
desc = create_skill_descriptor(skill["path"])
skill["instance"] = load_skill(desc, self.ws, skill["id"],
BLACKLISTED_SKILLS)
skill["last_modified"] = modified
if skill['instance'] is not None:
self.ws.emit(
Message(
'mycroft.skills.loaded', {
'folder': skill_folder,
'id': skill['id'],
'name': skill['instance'].name,
'modified': modified
}))
return True
else:
self.ws.emit(
Message('mycroft.skills.loading_failure', {
'folder': skill_folder,
'id': skill['id']
}))
return False
def load_skill_list(self, skills_to_load):
""" Load the specified list of skills from disk
Args:
skills_to_load (list): list of skill directory names to load
"""
if exists(SKILLS_DIR):
# checking skills dir and getting all priority skills there
skill_list = [
folder for folder in filter(
lambda x: os.path.isdir(os.path.join(SKILLS_DIR, x)),
os.listdir(SKILLS_DIR)) if folder in skills_to_load
]
for skill_folder in skill_list:
self._load_or_reload_skill(skill_folder)
def run(self):
""" Load skills and update periodically from disk and internet """
# Load priority skills first, in order (very first time this will
# occur before MSM has run)
self.load_skill_list(PRIORITY_SKILLS)
self._loaded_priority.set()
has_loaded = False
# Scan the file folder that contains Skills. If a Skill is updated,
# unload the existing version from memory and reload from the disk.
while not self._stop_event.is_set():
# check if skill updates are enabled
update = Configuration.get().get("skills",
{}).get("auto_update", True)
# Update skills once an hour if update is enabled
if (self.next_download and time.time() >= self.next_download
and update):
self.download_skills()
# Look for recently changed skill(s) needing a reload
if (exists(SKILLS_DIR) and (self.next_download or not update)):
# checking skills dir and getting all skills there
list = filter(
lambda x: os.path.isdir(os.path.join(SKILLS_DIR, x)),
os.listdir(SKILLS_DIR))
still_loading = False
for skill_folder in list:
still_loading = (self._load_or_reload_skill(skill_folder)
or still_loading)
if not has_loaded and not still_loading:
has_loaded = True
self.ws.emit(Message('mycroft.skills.initialized'))
# remember the date of the last modified skill
modified_dates = map(lambda x: x.get("last_modified"),
self.loaded_skills.values())
# Pause briefly before beginning next scan
time.sleep(2)
def send_skill_list(self, message=None):
"""
Send list of loaded skills.
"""
try:
self.ws.emit(
Message('mycroft.skills.list',
data={'skills': self.loaded_skills.keys()}))
except Exception as e:
LOG.exception(e)
def wait_loaded_priority(self):
""" Block until all priority skills have loaded """
while not self._loaded_priority.is_set():
time.sleep(1)
def stop(self):
""" Tell the manager to shutdown """
self._stop_event.set()
# Do a clean shutdown of all skills
for name, skill_info in self.loaded_skills.items():
instance = skill_info.get('instance')
if instance:
try:
instance._shutdown()
except Exception:
LOG.exception('Shutting down skill: ' + name)
def handle_converse_request(self, message):
""" Check if the targeted skill id can handle conversation
If supported, the conversation is invoked.
"""
skill_id = int(message.data["skill_id"])
utterances = message.data["utterances"]
lang = message.data["lang"]
# loop trough skills list and call converse for skill with skill_id
for skill in self.loaded_skills:
if self.loaded_skills[skill]["id"] == skill_id:
try:
instance = self.loaded_skills[skill]["instance"]
except BaseException:
LOG.error("converse requested but skill not loaded")
self.ws.emit(
Message("skill.converse.response", {
"skill_id": 0,
"result": False
}))
return
try:
result = instance.converse(utterances, lang)
self.ws.emit(
Message("skill.converse.response", {
"skill_id": skill_id,
"result": result
}))
return
except BaseException:
LOG.exception("Error in converse method for skill " +
str(skill_id))
self.ws.emit(
Message("skill.converse.response", {
"skill_id": 0,
"result": False
}))
class WiFi:
def __init__(self):
self.iface = pyw.winterfaces()[0]
self.ap = AccessPoint(self.iface)
self.server = None
self.ws = WebsocketClient()
self.enclosure = EnclosureAPI(self.ws)
self.init_events()
self.conn_monitor = None
self.conn_monitor_stop = threading.Event()
self.starting = False
def init_events(self):
'''
Register handlers for various websocket events used
to communicate with outside systems.
'''
# This event is generated by an outside mechanism. On a
# Mark 1 unit this comes from the Enclosure's WIFI menu
# item being selected.
self.ws.on('mycroft.wifi.start', self.start)
# Similar to the above. Resets to factory defaults
self.ws.on('mycroft.wifi.reset', self.reset)
# Similar to the above. Enable/disable SSH
self.ws.on('mycroft.enable.ssh', self.ssh_enable)
self.ws.on('mycroft.disable.ssh', self.ssh_disable)
# These events are generated by Javascript in the captive
# portal.
self.ws.on('mycroft.wifi.stop', self.stop)
self.ws.on('mycroft.wifi.scan', self.scan)
self.ws.on('mycroft.wifi.connect', self.connect)
def start(self, event=None):
'''
Fire up the MYCROFT access point for the user to connect to
with a phone or computer.
'''
if self.starting:
return
self.starting = True
LOG.info("Starting access point...")
self.intro_msg = ""
if event and event.data.get("msg"):
self.intro_msg = event.data.get("msg")
self.allow_timeout = True
if event and event.data.get("allow_timeout"):
self.allow_timeout = event.data.get("allow_timeout")
# Fire up our access point
self.ap.up()
if not self.server:
LOG.info("Creating web server...")
self.server = WebServer(self.ap.ip, 80)
LOG.info("Starting web server...")
self.server.start()
LOG.info("Created web server.")
LOG.info("Access point started!\n%s" % self.ap.__dict__)
self._start_connection_monitor()
def _connection_prompt(self, intro):
while self.ap.password is None or self.ap.password == "":
sleep(1) # give it time to load
# Speak the connection instructions and show the password on screen
passwordSpelled = ", ".join(self.ap.password)
self._speak_and_show(intro +
" Use your mobile device or computer to connect "
"to the wifi network 'MYCROFT'. Then enter the "
"password " + passwordSpelled,
self.ap.password)
def _speak_and_show(self, speak, show):
''' Communicate with the user throughout the process '''
self.ws.emit(Message("speak", {'utterance': speak}))
if show is None:
return
wait_while_speaking()
self.enclosure.mouth_text(show)
def _start_connection_monitor(self):
LOG.info("Starting monitor thread...\n")
if self.conn_monitor is not None:
LOG.info("Killing old thread...\n")
self.conn_monitor_stop.set()
self.conn_monitor_stop.wait()
self.conn_monitor = threading.Thread(
target=self._do_connection_monitor,
args={})
self.conn_monitor.daemon = True
self.conn_monitor.start()
LOG.info("Monitor thread setup complete.\n")
def _stop_connection_monitor(self):
''' Set flag that will let monitoring thread close '''
self.conn_monitor_stop.set()
def _do_connection_monitor(self):
LOG.info("Invoked monitor thread...\n")
mtimeLast = os.path.getmtime('/var/lib/misc/dnsmasq.leases')
bHasConnected = False
cARPFailures = 0
timeStarted = time.time()
timeLastAnnounced = timeStarted - 45 # first reminder in 90 secs
self.conn_monitor_stop.clear()
while not self.conn_monitor_stop.isSet():
# do our monitoring...
mtime = os.path.getmtime('/var/lib/misc/dnsmasq.leases')
if mtimeLast != mtime:
# Something changed in the dnsmasq lease file -
# presumably a (re)new lease
bHasConnected = True
cARPFailures = 0
mtimeLast = mtime
timeStarted = time.time() # reset start time after connection
timeLastAnnounced = time.time() - 45 # announce how to connect
if time.time() - timeStarted > 60 * 5 and self.allow_timeout:
# After 5 minutes, shut down the access point (unless the
# system has never been setup, in which case we stay up
# indefinitely)
LOG.info("Auto-shutdown of access point after 5 minutes")
self.stop()
continue
if time.time() - timeLastAnnounced >= 45:
if bHasConnected:
self._speak_and_show(
"Follow the prompt on your mobile device or computer "
"and choose a wifi network. If you don't get a "
"prompt, open your browser and go to start dot "
"mycroft dot A I.", "start.mycroft.ai")
else:
if self.intro_msg:
self._connection_prompt(self.intro_msg)
self.intro_msg = None # only speak the intro once
else:
self._connection_prompt("Allow me to walk you through "
"the wifi setup process.")
timeLastAnnounced = time.time()
if bHasConnected:
# Flush the ARP entries associated with our access point
# This will require all network hardware to re-register
# with the ARP tables if still present.
if cARPFailures == 0:
res = cli_no_output('ip', '-s', '-s', 'neigh', 'flush',
self.ap.subnet + '.0/24')
# Give ARP system time to re-register hardware
sleep(5)
# now look at the hardware that has responded, if no entry
# shows up on our access point after 2*5=10 seconds, the user
# has disconnected
if not self._is_ARP_filled():
cARPFailures += 1
if cARPFailures > 2:
self._connection_prompt("Connection lost.")
bHasConnected = False
else:
cARPFailures = 0
sleep(5) # wait a bit to prevent thread from hogging CPU
LOG.info("Exiting monitor thread...\n")
self.conn_monitor_stop.clear()
def _is_ARP_filled(self):
res = cli_no_output('/usr/sbin/arp', '-n')
out = str(res.get("stdout"))
if out:
# Parse output, skipping header
for o in out.split("\n")[1:]:
if o[0:len(self.ap.subnet)] == self.ap.subnet:
if "(incomplete)" in o:
# ping the IP to get the ARP table entry reloaded
ip_disconnected = o.split(" ")[0]
cli_no_output('/bin/ping', '-c', '1', '-W', '3',
ip_disconnected)
else:
return True # something on subnet is connected!
return False
def scan(self, event=None):
LOG.info("Scanning wifi connections...")
networks = {}
status = self.get_status()
for cell in Cell.all(self.iface):
if "x00" in cell.ssid:
continue # ignore hidden networks
update = True
ssid = cell.ssid
quality = self.get_quality(cell.quality)
# If there are duplicate network IDs (e.g. repeaters) only
# report the strongest signal
if networks.__contains__(ssid):
update = networks.get(ssid).get("quality") < quality
if update and ssid:
networks[ssid] = {
'quality': quality,
'encrypted': cell.encrypted,
'connected': self.is_connected(ssid, status)
}
self.ws.emit(Message("mycroft.wifi.scanned",
{'networks': networks}))
LOG.info("Wifi connections scanned!\n%s" % networks)
@staticmethod
def get_quality(quality):
values = quality.split("/")
return float(values[0]) / float(values[1])
def connect(self, event=None):
if event and event.data:
ssid = event.data.get("ssid")
connected = self.is_connected(ssid)
if connected:
LOG.warn("Mycroft is already connected to %s" % ssid)
else:
self.disconnect()
LOG.info("Connecting to: %s" % ssid)
nid = wpa(self.iface, 'add_network')
wpa(self.iface, 'set_network', nid, 'ssid', '"' + ssid + '"')
if event.data.__contains__("pass"):
psk = '"' + event.data.get("pass") + '"'
wpa(self.iface, 'set_network', nid, 'psk', psk)
else:
wpa(self.iface, 'set_network', nid, 'key_mgmt', 'NONE')
wpa(self.iface, 'enable', nid)
connected = self.get_connected(ssid)
if connected:
wpa(self.iface, 'save_config')
self.ws.emit(Message("mycroft.wifi.connected",
{'connected': connected}))
LOG.info("Connection status for %s = %s" % (ssid, connected))
def disconnect(self):
status = self.get_status()
nid = status.get("id")
if nid:
ssid = status.get("ssid")
wpa(self.iface, 'disable', nid)
LOG.info("Disconnecting %s id: %s" % (ssid, nid))
def get_status(self):
res = cli('wpa_cli', '-i', self.iface, 'status')
out = str(res.get("stdout"))
if out:
return dict(o.split("=") for o in out.split("\n")[:-1])
return {}
def get_connected(self, ssid, retry=5):
connected = self.is_connected(ssid)
while not connected and retry > 0:
sleep(2)
retry -= 1
connected = self.is_connected(ssid)
return connected
def is_connected(self, ssid, status=None):
status = status or self.get_status()
state = status.get("wpa_state")
return status.get("ssid") == ssid and state == "COMPLETED"
def stop(self, event=None):
LOG.info("Stopping access point...")
if is_speaking():
stop_speaking() # stop any assistance being spoken
self._stop_connection_monitor()
self.ap.down()
self.enclosure.mouth_reset() # remove "start.mycroft.ai"
self.starting = False
if self.server:
self.server.server.shutdown()
self.server.server.server_close()
self.server.join()
self.server = None
LOG.info("Access point stopped!")
def run(self):
try:
self.ws.run_forever()
except Exception as e:
LOG.error("Error: {0}".format(e))
self.stop()
def reset(self, event=None):
"""Reset the unit to the factory defaults """
LOG.info("Resetting the WPA_SUPPLICANT File")
try:
call(
"echo '" + WPA_SUPPLICANT +
"'> /etc/wpa_supplicant/wpa_supplicant.conf",
shell=True)
# UGLY BUT WORKS
call(RM_SKILLS)
except Exception as e:
LOG.error("Error: {0}".format(e))
def ssh_enable(self, event=None):
LOG.info("Enabling SSH")
try:
call('systemctl enable ssh.service', shell=True)
call('systemctl start ssh.service', shell=True)
except Exception as e:
LOG.error("Error: {0}".format(e))
def ssh_disable(self, event=None):
LOG.info("Disabling SSH")
try:
call('systemctl stop ssh.service', shell=True)
call('systemctl disable ssh.service', shell=True)
except Exception as e:
LOG.error("Error: {0}".format(e))
def check_connection():
"""
Check for network connection. If not paired trigger pairing.
Runs as a Timer every second until connection is detected.
"""
if connected():
enclosure = EnclosureAPI(ws)
if is_paired():
# Skip the sync message when unpaired because the prompt to go to
# home.mycrof.ai will be displayed by the pairing skill
enclosure.mouth_text(mycroft.dialog.get("message_synching.clock"))
# Force a sync of the local clock with the internet
ws.emit(Message("system.ntp.sync"))
time.sleep(15) # TODO: Generate/listen for a message response...
# Check if the time skewed significantly. If so, reboot
skew = abs((monotonic.monotonic() - start_ticks) -
(time.time() - start_clock))
if skew > 60*60:
# Time moved by over an hour in the NTP sync. Force a reboot to
# prevent weird things from occcurring due to the 'time warp'.
#
ws.emit(Message("speak", {'utterance':
mycroft.dialog.get("time.changed.reboot")}))
wait_while_speaking()
# provide visual indicators of the reboot
enclosure.mouth_text(mycroft.dialog.get("message_rebooting"))
enclosure.eyes_color(70, 65, 69) # soft gray
enclosure.eyes_spin()
# give the system time to finish processing enclosure messages
time.sleep(1.0)
# reboot
ws.emit(Message("system.reboot"))
return
ws.emit(Message('mycroft.internet.connected'))
# check for pairing, if not automatically start pairing
if not is_paired():
# begin the process
payload = {
'utterances': ["pair my device"],
'lang': "en-us"
}
ws.emit(Message("recognizer_loop:utterance", payload))
else:
if is_paired():
# Skip the message when unpaired because the prompt to go
# to home.mycrof.ai will be displayed by the pairing skill
enclosure.mouth_text(mycroft.dialog.get("message_updating"))
from mycroft.api import DeviceApi
api = DeviceApi()
api.update_version()
else:
thread = Timer(1, check_connection)
thread.daemon = True
thread.start()
class WiFi:
def __init__(self):
self.iface = pyw.winterfaces()[0]
self.ap = AccessPoint(self.iface)
self.server = None
self.ws = WebsocketClient()
ConfigurationManager.init(self.ws)
self.enclosure = EnclosureAPI(self.ws)
self.init_events()
self.conn_monitor = None
self.conn_monitor_stop = threading.Event()
def init_events(self):
'''
Register handlers for various websocket events used
to communicate with outside systems.
'''
# This event is generated by an outside mechanism. On a
# Holmes unit this comes from the Enclosure's menu item
# being selected.
self.ws.on('mycroft.wifi.start', self.start)
# These events are generated by Javascript in the captive
# portal.
self.ws.on('mycroft.wifi.stop', self.stop)
self.ws.on('mycroft.wifi.scan', self.scan)
self.ws.on('mycroft.wifi.connect', self.connect)
def start(self, event=None):
'''
Fire up the MYCROFT access point for the user to connect to
with a phone or computer.
'''
LOG.info("Starting access point...")
# Fire up our access point
self.ap.up()
if not self.server:
LOG.info("Creating web server...")
self.server = WebServer(self.ap.ip, 80)
LOG.info("Starting web server...")
self.server.start()
LOG.info("Created web server.")
LOG.info("Access point started!\n%s" % self.ap.__dict__)
self._start_connection_monitor()
def _connection_prompt(self, prefix):
# let the user know to connect to it...
passwordSpelled = ", ".join(self.ap.password)
self._speak_and_show(
prefix + " Use your mobile device or computer to "
"connect to the wifi network "
"'MYCROFT'; Then enter the uppercase "
"password " + passwordSpelled,
self.ap.password)
def _speak_and_show(self, speak, show):
''' Communicate with the user throughout the process '''
self.ws.emit(Message("speak", {'utterance': speak}))
if show is None:
return
# TODO: This sleep should not be necessary, but without it the
# text to be displayed by enclosure.mouth_text() gets
# wiped out immediately when the utterance above is
# begins processing.
# Remove the sleep once this behavior is corrected.
sleep(0.25)
self.enclosure.mouth_text(show)
def _start_connection_monitor(self):
LOG.info("Starting monitor thread...\n")
if self.conn_monitor is not None:
LOG.info("Killing old thread...\n")
self.conn_monitor_stop.set()
self.conn_monitor_stop.wait()
self.conn_monitor = threading.Thread(
target=self._do_connection_monitor,
args={})
self.conn_monitor.daemon = True
self.conn_monitor.start()
LOG.info("Monitor thread setup complete.\n")
def _stop_connection_monitor(self):
''' Set flag that will let monitoring thread close '''
self.conn_monitor_stop.set()
def _do_connection_monitor(self):
LOG.info("Invoked monitor thread...\n")
mtimeLast = os.path.getmtime('/var/lib/misc/dnsmasq.leases')
bHasConnected = False
cARPFailures = 0
timeStarted = time.time()
timeLastAnnounced = 0 # force first announcement to now
self.conn_monitor_stop.clear()
while not self.conn_monitor_stop.isSet():
# do our monitoring...
mtime = os.path.getmtime('/var/lib/misc/dnsmasq.leases')
if mtimeLast != mtime:
# Something changed in the dnsmasq lease file -
# presumably a (re)new lease
bHasConnected = True
cARPFailures = 0
mtimeLast = mtime
timeStarted = time.time() # reset start time after connection
timeLastAnnounced = time.time() - 45 # announce how to connect
if time.time() - timeStarted > 60 * 5:
# After 5 minutes, shut down the access point
LOG.info("Auto-shutdown of access point after 5 minutes")
self.stop()
continue
if time.time() - timeLastAnnounced >= 45:
if bHasConnected:
self._speak_and_show(
"Now you can open your browser and go to start dot "
"mycroft dot A I, then follow the instructions given "
" there",
"start.mycroft.ai")
else:
self._connection_prompt("Allow me to walk you through the "
" wifi setup process; ")
timeLastAnnounced = time.time()
if bHasConnected:
# Flush the ARP entries associated with our access point
# This will require all network hardware to re-register
# with the ARP tables if still present.
if cARPFailures == 0:
res = cli_no_output('ip', '-s', '-s', 'neigh', 'flush',
self.ap.subnet + '.0/24')
# Give ARP system time to re-register hardware
sleep(5)
# now look at the hardware that has responded, if no entry
# shows up on our access point after 2*5=10 seconds, the user
# has disconnected
if not self._is_ARP_filled():
cARPFailures += 1
if cARPFailures > 2:
self._connection_prompt("Connection lost,")
bHasConnected = False
else:
cARPFailures = 0
sleep(5) # wait a bit to prevent thread from hogging CPU
LOG.info("Exiting monitor thread...\n")
self.conn_monitor_stop.clear()
def _is_ARP_filled(self):
res = cli_no_output('/usr/sbin/arp', '-n')
out = str(res.get("stdout"))
if out:
# Parse output, skipping header
for o in out.split("\n")[1:]:
if o[0:len(self.ap.subnet)] == self.ap.subnet:
if "(incomplete)" in o:
# ping the IP to get the ARP table entry reloaded
ip_disconnected = o.split(" ")[0]
cli_no_output('/bin/ping', '-c', '1', '-W', '3',
ip_disconnected)
else:
return True # something on subnet is connected!
return False
def scan(self, event=None):
LOG.info("Scanning wifi connections...")
networks = {}
status = self.get_status()
for cell in Cell.all(self.iface):
update = True
ssid = cell.ssid
quality = self.get_quality(cell.quality)
# If there are duplicate network IDs (e.g. repeaters) only
# report the strongest signal
if networks.__contains__(ssid):
update = networks.get(ssid).get("quality") < quality
if update and ssid:
networks[ssid] = {
'quality': quality,
'encrypted': cell.encrypted,
'connected': self.is_connected(ssid, status)
}
self.ws.emit(Message("mycroft.wifi.scanned",
{'networks': networks}))
LOG.info("Wifi connections scanned!\n%s" % networks)
@staticmethod
def get_quality(quality):
values = quality.split("/")
return float(values[0]) / float(values[1])
def connect(self, event=None):
if event and event.data:
ssid = event.data.get("ssid")
connected = self.is_connected(ssid)
if connected:
LOG.warn("Mycroft is already connected to %s" % ssid)
else:
self.disconnect()
LOG.info("Connecting to: %s" % ssid)
nid = wpa(self.iface, 'add_network')
wpa(self.iface, 'set_network', nid, 'ssid', '"' + ssid + '"')
if event.data.__contains__("pass"):
psk = '"' + event.data.get("pass") + '"'
wpa(self.iface, 'set_network', nid, 'psk', psk)
else:
wpa(self.iface, 'set_network', nid, 'key_mgmt', 'NONE')
wpa(self.iface, 'enable', nid)
connected = self.get_connected(ssid)
if connected:
wpa(self.iface, 'save_config')
self.ws.emit(Message("mycroft.wifi.connected",
{'connected': connected}))
LOG.info("Connection status for %s = %s" % (ssid, connected))
if connected:
self.ws.emit(Message("speak", {
'utterance': "Thank you, I'm now connected to the "
"internet and ready for use"}))
# TODO: emit something that triggers a pairing check
def disconnect(self):
status = self.get_status()
nid = status.get("id")
if nid:
ssid = status.get("ssid")
wpa(self.iface, 'disable', nid)
LOG.info("Disconnecting %s id: %s" % (ssid, nid))
def get_status(self):
res = cli('wpa_cli', '-i', self.iface, 'status')
out = str(res.get("stdout"))
if out:
return dict(o.split("=") for o in out.split("\n")[:-1])
return {}
def get_connected(self, ssid, retry=5):
connected = self.is_connected(ssid)
while not connected and retry > 0:
sleep(2)
retry -= 1
connected = self.is_connected(ssid)
return connected
def is_connected(self, ssid, status=None):
status = status or self.get_status()
state = status.get("wpa_state")
return status.get("ssid") == ssid and state == "COMPLETED"
def stop(self, event=None):
LOG.info("Stopping access point...")
self._stop_connection_monitor()
self.ap.down()
if self.server:
self.server.server.shutdown()
self.server.server.server_close()
self.server.join()
self.server = None
LOG.info("Access point stopped!")
def _do_net_check(self):
# give system 5 seconds to resolve network or get plugged in
sleep(5)
LOG.info("Checking internet connection again")
if not connected() and self.conn_monitor is None:
# TODO: Enclosure/localization
self._speak_and_show(
"This device is not connected to the Internet. Either plug "
"in a network cable or hold the button on top for two "
"seconds, then select wifi from the menu", None)
def run(self):
try:
# When the system first boots up, check for a valid internet
# connection.
LOG.info("Checking internet connection")
if not connected():
LOG.info("No connection initially, waiting 20...")
self.net_check = threading.Thread(
target=self._do_net_check,
args={})
self.net_check.daemon = True
self.net_check.start()
else:
LOG.info("Connection found!")
self.ws.run_forever()
except Exception as e:
LOG.error("Error: {0}".format(e))
self.stop()
