def public_keys():
if not current_flamenco.jwt.usable:
raise wz_exceptions.NotImplemented(
'JWT keystore is not usable at the moment')
last_modified = current_flamenco.jwt.public_keys_last_modified
if request.headers.get('If-Modified-Since', '') == last_modified:
return Response('', status=304) # Not Modified
pubs = current_flamenco.jwt.public_keys
if not pubs:
raise wz_exceptions.NotImplemented('No public JWT keys available')
return Response(pubs,
content_type='text/plain',
headers={'Last-Modified': last_modified})
def post(self, entity_id):
# TODO
# - read paramterrs
# - start a session
# - get a lock of the resource
# - actuation
# - verify the actuation
# - post the updated value to the timeseries database
# - close the session - abort the session if anything goes wrong.
args = reqparser.parse_args()
actuation_value = args.value
scheduled_time = args.get('scheduled_time', None)
if scheduled_time:
# TODO: Implement this
raise exceptions.NotImplemented(
'Currently only immediate actuation is implemented.')
with self.lock_manager.advisory_lock(entity_id) as lock_acquired:
assert lock_acquired, exceptions.BadRequest(
'Lock for {0} cannot be acquired'.format(entity_id))
self.actuation(entity_id, actuation_value)
actuated_time = arrow.get()
data = [[entity_id, actuated_time.timestamp, actuation_value]]
self.ts_db.add_data(data)
return None
raise exceptions.InternalServerError('This should not be reached.')
def _get_method(self, method):
try:
meth = getattr(self.model, method)
except AttributeError:
raise exceptions.NotImplemented(
"Not implemented by underlying model (loaded '%s')" % self.name
)
return meth
def post(self):
args = reqparser.parse_args()
content_type = args.content_type
# TODO: Verify/Authorize the user for the turtle file
if content_type == 'application/json':
entities = marshal(args, entities_model)['entities']
entities = self.add_entities_json(entities)
elif content_type == 'text/turtle':
raise exceptions.NotImplemented(
'TODO: Implement entities addition for Content-Type {0}.'.
format(content_type))
raw_ttl = request.data.decode('utf-8')
self.add_entities_ttl(raw_ttl)
else:
raise exceptions.NotImplemented(
'TODO: Implement entities addition for Content-Type {0}.'.
format(content_type))
return {'entities': entities}, 201
def __init__(self, limit):
self.limit = limit
# Set defaults
self.code = 429
self.body = self.get_body()
self.headers = self.get_headers()
# Get the description
if limit.error_message:
self.description = limit.error_message if not callable(
limit.error_message) else limit.error_message()
else:
self.description = text_type(limit.limit)
# If error is given, get body & headers
if self.limit.error_code:
self.code = limit.error_code
exception = exceptions.HTTPException(description=self.description)
# Some common error codes, can add more here
if self.code == 400:
exception = exceptions.BadRequest()
elif self.code == 401:
exception = exceptions.Unauthorized()
elif self.code == 403:
exception = exceptions.Forbidden()
elif self.code == 404:
exception = exceptions.NotFound()
elif self.code == 405:
exception = exceptions.MethodNotAllowed()
elif self.code == 406:
exception = exceptions.NotAcceptable()
elif self.code == 418:
exception = exceptions.ImATeapot() # <3
elif self.code == 500:
exception = exceptions.InternalServerError()
elif self.code == 501:
exception = exceptions.NotImplemented()
# Update body & headers
self.body = exception.get_body()
self.headers = exception.get_headers()
else:
exception = exceptions.TooManyRequests(
description=self.description)
# Update body & headers
self.body = exception.get_body()
self.headers = exception.get_headers()
super(RateLimitExceeded,
self).__init__(description=self.description,
response=Response(self.body, self.code,
self.headers))
def workflows_put(wf_uuid, wf_version, body):
# TODO: to be implemented
logger.debug("PUT called for workflow (%s,%s)", wf_uuid, wf_version)
# try:
# wf = model.WorkflowVersion.query.get(wf_id)
# except sqlalchemy.exc.DataError:
# return "Invalid ID", 400
# wf.name = body['name']
# db.session.commit()
# return connexion.NoContent, 200
raise http_exceptions.NotImplemented()
def generate_token(manager_id: str):
manager_oid = str2id(manager_id)
manager = mongo.find_one_or_404('flamenco_managers', manager_oid)
# There are three ways in which a user can get here. One is authenticated via
# Authorization header (either Bearer token or Basic token:subtoken), and the
# other is via an already-existing browser session.
# In the latter case it's a redirect from a Flamenco Manager and we need to
# check the timeout and HMAC.
if not request.headers.get('Authorization'):
hasher = current_flamenco.manager_manager.hasher(manager_oid)
if hasher is None:
raise wz_exceptions.InternalServerError(
'Flamenco Manager not linked to this server')
expires = request.args.get('expires', '')
string_to_hash = f'{expires}-{manager_id}'
hasher.update(string_to_hash.encode('utf8'))
actual_hmac = hasher.hexdigest()
query_hmac = request.args.get('hmac', '')
if not hmac.compare_digest(query_hmac, actual_hmac):
raise wz_exceptions.Unauthorized('Bad HMAC')
# Only parse the timestamp after we learned we can trust it.
expire_timestamp = dateutil.parser.parse(expires)
validity_seconds_left = (expire_timestamp - utcnow()).total_seconds()
if validity_seconds_left < 0:
raise wz_exceptions.Unauthorized('Link expired')
if validity_seconds_left > 900:
# Flamenco Manager generates links that are valid for less than a minute, so
# if it's more than 15 minutes in the future, it's bad.
raise wz_exceptions.Unauthorized('Link too far in the future')
user = authentication.current_user()
if not current_flamenco.manager_manager.user_may_use(mngr_doc=manager):
log.warning(
'Account %s called %s for manager %s without access to that manager',
user.user_id, request.url, manager_oid)
raise wz_exceptions.Unauthorized()
jwt = current_flamenco.jwt
if not jwt.usable:
raise wz_exceptions.NotImplemented(
'JWT keystore is not usable at the moment')
log.info('Generating JWT key for user_id=%s manager_id=%s remote_addr=%s',
user.user_id, manager_id, request.remote_addr)
key_for_manager = jwt.generate_key_for_manager(manager_oid, user.user_id)
return Response(key_for_manager, content_type='text/plain')
def numpy_pandas_function_from_str(f):
"""
reconstruct function from string representation
"""
if f.startswith(np.__name__):
mod = np
elif f.startswith(pd.__name__):
mod = pd
elif f.startswith(builtins.__name__):
mod = builtins
else:
msg = ("Function {} not recognized; only numpy, pandas, or builtin "
"functions are supported.")
raise wz_ex.NotImplemented(msg.format(f))
fcn = reduce(getattr, f.split('.')[1:], mod)
return fcn
def actuate(self, entity_id, value):
"""Actuates an entity with a given value.
This function sets the current value of the entity with `entity_id` as `value` in "the actual system" such as BACnet devices. The value may have a physical impact in the real world.
Args:
entity_id: The identifier of an entity.
value: A numeric value that the request wants to actuate of the entity.
Returns:
None. If the actuation is successful, the function completes. Otherwise, it raises an exception.
Raises:
TODO
"""
raise exceptions.NotImplemented('This should be overriden by an actual implementation.')
def get(self, report_uid, assertions_uid):
"""
Get an Assertion report (JSON) for a specific Testplan report given
their uids.
"""
raise exceptions.NotImplemented() # pylint: disable=notimplemented-raised
def wrap(*args, **kwargs):
try:
return f(*args, **kwargs)
except NotImplementedError:
raise exceptions.NotImplemented("Model does not implement "
"this functionality")
def wrapped(a, b):
raise wz_exceptions.NotImplemented('nee')
def not_implemented(message=exceptions.NotImplemented().description):
response = jsonify({'error': 'Not Implemented', 'message': message})
response.status_code = 501
return response
def get(self):
# TODO: Implement
raise exceptions.NotImplemented('TODO: List all entities and types')
return res
def delete(self, entity_id):
raise exceptions.NotImplemented('TODO: Delete corresponding entity.')
return None
