313 lines
11 KiB
Python
313 lines
11 KiB
Python
# Copyright 2017 Mycroft AI Inc.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
#
|
|
"""
|
|
This module provides the SkillSettings dictionary, which is a simple
|
|
extension of the python dict to enable storing.
|
|
|
|
Example:
|
|
from mycroft.skill.settings import SkillSettings
|
|
|
|
s = SkillSettings('./settings.json')
|
|
s['meaning of life'] = 42
|
|
s['flower pot sayings'] = 'Not again...'
|
|
s.store()
|
|
"""
|
|
|
|
import json
|
|
from threading import Timer
|
|
from os.path import isfile, join, expanduser
|
|
|
|
from mycroft.api import DeviceApi
|
|
from mycroft.util.log import LOG
|
|
from mycroft.configuration import ConfigurationManager
|
|
|
|
|
|
class SkillSettings(dict):
|
|
""" SkillSettings creates a dictionary that can easily be stored
|
|
to file, serialized as json. It also syncs to the backend for
|
|
skill settings
|
|
|
|
Args:
|
|
settings_file (str): Path to storage file
|
|
"""
|
|
|
|
def __init__(self, directory, name):
|
|
super(SkillSettings, self).__init__()
|
|
self.api = DeviceApi()
|
|
self._device_identity = self.api.identity.uuid
|
|
self.config = ConfigurationManager.get()
|
|
self.name = name
|
|
# set file paths
|
|
self._settings_path = join(directory, 'settings.json')
|
|
self._meta_path = join(directory, 'settingsmeta.json')
|
|
self._api_path = "/" + self._device_identity + "/skill"
|
|
self.is_alive = True
|
|
self.loaded_hash = hash(str(self))
|
|
|
|
# if settingsmeta.json exists
|
|
# this block of code is a control flow for
|
|
# different scenarios that may arises with settingsmeta
|
|
if isfile(self._meta_path):
|
|
LOG.info("settingsmeta.json exist for {}".format(self.name))
|
|
settings_meta = self._load_settings_meta()
|
|
hashed_meta = hash(str(settings_meta)+str(self._device_identity))
|
|
# check if hash is different from the saved hashed
|
|
if self._is_new_hash(hashed_meta):
|
|
LOG.info("looks like settingsmeta.json " +
|
|
"has changed for {}".format(self.name))
|
|
# TODO: once the delete api for device is created uncomment
|
|
if self._uuid_exist():
|
|
try:
|
|
LOG.info("a uuid exist for {}".format(self.name) +
|
|
" deleting old one")
|
|
old_uuid = self._load_uuid()
|
|
self._delete_metatdata(old_uuid)
|
|
except Exception as e:
|
|
LOG.info(e)
|
|
LOG.info("sending settingsmeta.json for {}".format(self.name) +
|
|
" to home.mycroft.ai")
|
|
new_uuid = self._send_settings_meta(settings_meta, hashed_meta)
|
|
self._save_uuid(new_uuid)
|
|
self._save_hash(hashed_meta)
|
|
else: # if hash is old
|
|
found_in_backend = False
|
|
settings = self._get_remote_settings()
|
|
# checks backend if th settings have been deleted
|
|
# through web ui
|
|
for skill in settings:
|
|
if skill["identifier"] == str(hashed_meta):
|
|
found_in_backend = True
|
|
# if it's been deleted from web ui
|
|
# resend the settingsmeta.json
|
|
if found_in_backend is False:
|
|
LOG.info("seems like it got deleted from home... " +
|
|
"sending settingsmeta.json for " +
|
|
"{}".format(self.name))
|
|
new_uuid = self._send_settings_meta(
|
|
settings_meta, hashed_meta)
|
|
self._save_uuid(new_uuid)
|
|
self._save_hash(hashed_meta)
|
|
|
|
t = Timer(60, self._poll_skill_settings, [hashed_meta])
|
|
t.daemon = True
|
|
t.start()
|
|
|
|
self.load_skill_settings()
|
|
|
|
@property
|
|
def _is_stored(self):
|
|
return hash(str(self)) == self.loaded_hash
|
|
|
|
def __getitem__(self, key):
|
|
""" Get key """
|
|
return super(SkillSettings, self).__getitem__(key)
|
|
|
|
def __setitem__(self, key, value):
|
|
""" Add/Update key. """
|
|
return super(SkillSettings, self).__setitem__(key, value)
|
|
|
|
def _load_settings_meta(self):
|
|
""" loads settings metadata from skills path """
|
|
with open(self._meta_path) as f:
|
|
data = json.load(f)
|
|
return data
|
|
|
|
def _send_settings_meta(self, settings_meta, hashed_meta):
|
|
""" send settingsmeta.json to the backend
|
|
|
|
Args:
|
|
param1 (dict): dictionary of the current settings meta data
|
|
param1 (int): hashed settings meta data
|
|
|
|
Returns:
|
|
uuid (str): a unique id for the setting meta data
|
|
"""
|
|
try:
|
|
settings_meta["identifier"] = str(hashed_meta)
|
|
self._put_metadata(settings_meta)
|
|
settings = self._get_remote_settings()
|
|
skill_identity = str(hashed_meta)
|
|
uuid = None
|
|
# TODO: note uuid should be returned from the put request
|
|
for skill_setting in settings:
|
|
if skill_setting['identifier'] == skill_identity:
|
|
uuid = skill_setting["uuid"]
|
|
return uuid
|
|
except Exception as e:
|
|
LOG.error(e)
|
|
|
|
def _load_uuid(self):
|
|
""" loads uuid
|
|
|
|
Returns:
|
|
uuid (str): uuid of the previous settingsmeta
|
|
"""
|
|
directory = self.config.get("skills")["directory"]
|
|
directory = join(directory, self.name)
|
|
directory = expanduser(directory)
|
|
uuid_file = join(directory, 'uuid')
|
|
if isfile(uuid_file):
|
|
with open(uuid_file, 'r') as f:
|
|
uuid = f.read()
|
|
return uuid
|
|
|
|
def _save_uuid(self, uuid):
|
|
""" saves uuid to path
|
|
|
|
Args:
|
|
param1 (str): uuid of new seetingsmeta
|
|
"""
|
|
LOG.info("saving uuid {}".format(str(uuid)))
|
|
directory = self.config.get("skills")["directory"]
|
|
directory = join(directory, self.name)
|
|
directory = expanduser(directory)
|
|
uuid_file = join(directory, 'uuid')
|
|
with open(uuid_file, 'w') as f:
|
|
f.write(str(uuid))
|
|
|
|
def _save_hash(self, hashed_meta):
|
|
""" saves hashed_meta to path
|
|
|
|
Args:
|
|
param1 (int): hashed of new seetingsmeta
|
|
"""
|
|
LOG.info("saving hash {}".format(str(hashed_meta)))
|
|
directory = self.config.get("skills")["directory"]
|
|
directory = join(directory, self.name)
|
|
directory = expanduser(directory)
|
|
hash_file = join(directory, 'hash')
|
|
with open(hash_file, 'w') as f:
|
|
f.write(str(hashed_meta))
|
|
|
|
def _uuid_exist(self):
|
|
""" checks if there is a uuid file
|
|
|
|
Returns:
|
|
bool: True if uuid file exist False otherwise
|
|
"""
|
|
directory = self.config.get("skills")["directory"]
|
|
directory = join(directory, self.name)
|
|
directory = expanduser(directory)
|
|
uuid_file = join(directory, 'uuid')
|
|
return isfile(uuid_file)
|
|
|
|
def _is_new_hash(self, hashed_meta):
|
|
""" checks if the stored hash is the same as current.
|
|
if the hashed file does not exist, usually in the
|
|
case of first load, then the create it and return True
|
|
|
|
Args:
|
|
param1 (int): hash of metadata and uuid of device
|
|
|
|
Returns:
|
|
bool: True if hash is new False otherwise
|
|
"""
|
|
directory = self.config.get("skills")["directory"]
|
|
directory = join(directory, self.name)
|
|
directory = expanduser(directory)
|
|
hash_file = join(directory, 'hash')
|
|
if isfile(hash_file):
|
|
with open(hash_file, 'r') as f:
|
|
current_hash = f.read()
|
|
return False if current_hash == str(hashed_meta) else True
|
|
return True
|
|
|
|
def _poll_skill_settings(self, hashed_meta):
|
|
""" If identifier exists for this skill poll to backend to
|
|
request settings and store it if it changes
|
|
TODO: implement as websocket
|
|
|
|
Args:
|
|
param1 (int): the hashed identifier
|
|
|
|
"""
|
|
LOG.info("getting settings from home.mycroft.ai")
|
|
try:
|
|
# update settings
|
|
settings = self._get_remote_settings()
|
|
skill_identity = str(hashed_meta)
|
|
for skill_setting in settings:
|
|
if skill_setting['identifier'] == skill_identity:
|
|
sections = skill_setting['skillMetadata']['sections']
|
|
for section in sections:
|
|
for field in section["fields"]:
|
|
self.__setitem__(field["name"], field["value"])
|
|
|
|
# store value if settings has changed from backend
|
|
self.store()
|
|
|
|
except Exception as e:
|
|
LOG.error(e)
|
|
|
|
if self.is_alive:
|
|
# continues to poll settings every 60 seconds
|
|
t = Timer(60, self._poll_skill_settings, [hashed_meta])
|
|
t.daemon = True
|
|
t.start()
|
|
|
|
def load_skill_settings(self):
|
|
""" If settings.json exist, open and read stored values into self """
|
|
if isfile(self._settings_path):
|
|
with open(self._settings_path) as f:
|
|
try:
|
|
json_data = json.load(f)
|
|
for key in json_data:
|
|
self.__setitem__(key, json_data[key])
|
|
except Exception as e:
|
|
# TODO: Show error on webUI. Dev will have to fix
|
|
# metadata to be able to edit later.
|
|
LOG.error(e)
|
|
|
|
def _get_remote_settings(self):
|
|
""" Get skill settings for this device from backend """
|
|
settings = self.api.request({
|
|
"method": "GET",
|
|
"path": self._api_path
|
|
})
|
|
settings = [skills for skills in settings if skills is not None]
|
|
return settings
|
|
|
|
def _put_metadata(self, settings_meta):
|
|
""" PUT settingsmeta to backend to be configured in home.mycroft.ai.
|
|
used in plcae of POST and PATCH
|
|
"""
|
|
return self.api.request({
|
|
"method": "PUT",
|
|
"path": self._api_path,
|
|
"json": settings_meta
|
|
})
|
|
|
|
def _delete_metatdata(self, uuid):
|
|
""" Deletes the current skill metadata
|
|
|
|
Args:
|
|
param1 (str): unique id of the skill
|
|
"""
|
|
return self.api.request({
|
|
"method": "DELETE",
|
|
"path": self._api_path + "/{}".format(uuid)
|
|
})
|
|
|
|
def store(self, force=False):
|
|
""" Store dictionary to file if a change has occured.
|
|
|
|
Args:
|
|
force: Force write despite no change
|
|
"""
|
|
if force or not self._is_stored:
|
|
with open(self._settings_path, 'w') as f:
|
|
json.dump(self, f)
|
|
self.loaded_hash = hash(str(self))
|