def prepare(self):
"""Prepare to handler reply."""
self.set_header('Content-Type', 'application/json')
# get requests do not require authentication
if self.request.method == "GET":
return
accounts_manager = srv_or_die("accountsmanager")
projects_manager = srv_or_die("projectsmanager")
auth_header = self.request.headers.get('Authorization')
if auth_header is None or not auth_header.startswith('Basic '):
self.set_header('WWW-Authenticate', 'Basic realm=Restricted')
self.send_error(401, message="Missing authorization header")
return
auth_bytes = bytes(auth_header[6:], 'utf-8')
auth_decoded = base64.b64decode(auth_bytes).decode()
username, password = auth_decoded.split(':', 2)
# account does not exists
if not accounts_manager.check_permission(username, password):
self.send_error(401,
message="Invalid username/password combination")
return
account = accounts_manager.accounts[username]
# root can do everything
if account.username == "root":
return
# check if logged user is accessing his/her own account
if self.request.uri.startswith("/api/v1/accounts"):
pattern = re.compile("/api/v1/accounts/([a-zA-Z0-9:-]*)/?")
match = pattern.match(self.request.uri)
if match and match.group(1):
username = match.group(1)
if username == account.username:
return
# check if logged user is accessing one of his/her projects
if self.request.uri.startswith("/api/v1/projects"):
pattern = re.compile("/api/v1/projects/([a-zA-Z0-9-]*)/?")
match = pattern.match(self.request.uri)
if match and match.group(1):
project_id = UUID(match.group(1))
if project_id in projects_manager.projects:
project = projects_manager.projects[project_id]
if account.username == project.owner:
return
self.send_error(401, message="URI not authorized")
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# Save pointer to LVAPPManager
self.lvapp_manager = \
srv_or_die("empower.managers.ranmanager.lvapp.lvappmanager")
# Save pointer to VBSPManager
self.vbsp_manager = \
srv_or_die("empower.managers.ranmanager.vbsp.vbspmanager")
def start(self):
"""Start api manager."""
super().start()
self.accounts_manager = srv_or_die("accountsmanager")
self.projects_manager = srv_or_die("projectsmanager")
self.http_server.listen(self.port)
self.log.info("Listening on port %u", self.port)
self.http_server.start()
def create(self, desc, project_id, owner, wifi_props=None, lte_props=None):
"""Create new project."""
if project_id in self.projects:
raise ValueError("Project %s already defined" % project_id)
accounts_manager = srv_or_die("accountsmanager")
if owner not in accounts_manager.accounts:
raise KeyError("Username %s not found" % owner)
project = Project(project_id=project_id, desc=desc, owner=owner)
if wifi_props:
project.wifi_props = EmbeddedWiFiProps(**wifi_props)
if lte_props:
project.lte_props = EmbeddedLTEProps(**lte_props)
project.save()
self.projects[project_id] = project
project.upsert_wifi_slice(slice_id=0)
project.upsert_lte_slice(slice_id=0)
self.projects[project_id].start_services()
return self.projects[project_id]
def start(self, load):
"""Start control loop."""
# Register handlers for this services
api_manager = srv_or_die("empower.managers.apimanager.apimanager")
for handler in self.HANDLERS:
api_manager.register_handler(handler)
# Set pointer to this service
for handler in self.HANDLERS:
handler.service = self
# load configuration from database
if load:
self.load()
# Not supposed to run a loop
if self.every == -1:
return
# Start the control loop
self.worker = \
tornado.ioloop.PeriodicCallback(self.loop, self.every)
self.worker.start()
def start(self, load):
"""Start worker."""
# Set pointer to context
env_manager = srv_or_die("empower.managers.envmanager.envmanager")
self.context = env_manager.env
# start the service
super().start(load)
def start(self, load=True):
"""Start worker."""
# Set pointer to context
conf_manager = srv_or_die("empower.services.confmanager.confmanager")
self.context = conf_manager.conf
# start the service
super().start(load)
def start(self, load):
"""Start projects manager."""
super().start(load)
self.accounts_manager = \
srv_or_die("empower.managers.accountsmanager.accountsmanager")
for project in Project.objects.all():
self.projects[project.project_id] = project
self.projects[project.project_id].start_services()
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# List of services in this Env/Project
self.services = {}
# Save pointer to EnvManager
self.manager = srv_or_die("envmanager")
# Save pointer to LVAPPManager
self.lvapp_manager = srv_or_die("lvappmanager")
# Save pointer to VBSPManager
self.vbsp_manager = srv_or_die("vbspmanager")
# Save pointer to TimeSeriesManaget
self.ts_manager = srv_or_die("tsmanager")
# Save pointer to ApiManager
self.api_manager = srv_or_die("apimanager")
def post(self):
"""Process login credentials."""
username = self.get_argument("username", "")
password = self.get_argument("password", "")
accounts_manager = srv_or_die("accountsmanager")
if accounts_manager.check_permission(username, password):
self.set_secure_cookie("username", username)
self.redirect("/index.html")
else:
self.clear_cookie("username")
self.redirect("/auth/login?error=Wrong credentials!")
def get_project(self):
"""Get the current project or return None if not project is set."""
# check if a project has been selected
project_id = self.get_secure_cookie("project_id")
if not project_id:
return None
project_id = UUID(project_id.decode('UTF-8'))
projects_manager = srv_or_die("projectsmanager")
project = projects_manager.projects[project_id]
return project
def start(self, load=True):
"""Start worker."""
# Set pointer to context
projects_manager = \
srv_or_die("empower.services.projectsmanager.projectsmanager")
self.context = projects_manager.projects[self.project_id]
# Register default callbacks (LVAPP)
lvapp.register_callback(lvapp.PT_CLIENT_LEAVE, self._lvap_leave)
lvapp.register_callback(lvapp.PT_CLIENT_JOIN, self._lvap_join)
lvapp.register_callback(lvapp.PT_DEVICE_UP, self._wtp_up)
lvapp.register_callback(lvapp.PT_DEVICE_DOWN, self._wtp_down)
# start the service
super().start(load)
def get(self):
"""Set the active project."""
username = self.get_secure_cookie("username").decode('UTF-8')
# if root deselect project
if username == "root":
self.clear_cookie("project_id")
self.redirect('/')
return
# check if the project id is in the URL
project_id = self.get_argument("project_id", None)
# reset project selected
if not project_id:
self.clear_cookie("project_id")
self.redirect('/')
return
try:
# set project
project_id = UUID(project_id)
projects_manager = srv_or_die("projectsmanager")
project = projects_manager.projects[project_id]
if project.owner != username:
self.clear_cookie("project_id")
self.redirect('/')
return
self.set_secure_cookie("project_id", str(project.project_id))
except KeyError:
self.clear_cookie("project_id")
except ValueError:
self.clear_cookie("project_id")
self.redirect('/')
def get(self, args=None):
"""Render index page."""
try:
username = self.get_secure_cookie("username").decode('UTF-8')
accounts_manager = srv_or_die("accountsmanager")
account = accounts_manager.accounts[username]
page = "index.html" if not args else "%s.html" % args
self.render(page,
username=account.username,
password=account.password,
name=account.name,
email=account.email,
project=self.get_project())
except KeyError as ex:
self.send_error(404, message=str(ex))
except ValueError as ex:
self.send_error(400, message=str(ex))
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# Save pointer to ProjectManager
self.manager = srv_or_die("projectsmanager")
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.accounts_manager = \
srv_or_die("empower.services.accountsmanager.accountsmanager")
