305 lines
12 KiB
Python
305 lines
12 KiB
Python
# Copyright (c) 2013-2015 Rackspace, 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.
|
|
|
|
"""
|
|
Task resources for the Barbican API.
|
|
"""
|
|
import abc
|
|
|
|
from barbican import api
|
|
from barbican.common import utils
|
|
from barbican import i18n as u
|
|
from barbican.model import models
|
|
from barbican.model import repositories as rep
|
|
from barbican.plugin import resources as plugin
|
|
from barbican.tasks import common
|
|
|
|
|
|
LOG = utils.getLogger(__name__)
|
|
|
|
|
|
class BaseTask(object, metaclass=abc.ABCMeta):
|
|
"""Base asynchronous task."""
|
|
|
|
@abc.abstractmethod
|
|
def get_name(self):
|
|
"""Localized task name
|
|
|
|
A hook method to return a short localized name for this task.
|
|
The returned name in the form 'u.('Verb Noun')'. For example:
|
|
u._('Create Secret')
|
|
"""
|
|
|
|
def process_and_suppress_exceptions(self, *args, **kwargs):
|
|
"""Invokes the process() template method, suppressing all exceptions.
|
|
|
|
TODO(john-wood-w) This method suppresses exceptions for flows that
|
|
do not want to rollback database modifications in reaction to such
|
|
exceptions, as this could also rollback the marking of the entity
|
|
(eg. order) in the ERROR status via the handle_error() call below.
|
|
For Liberty, we might want to consider a workflow manager instead of
|
|
these process_xxxx() method as shown here:
|
|
https://gist.github.com/jfwood/a8130265b0db3c793ec8
|
|
|
|
:param args: List of arguments passed in from the client.
|
|
:param kwargs: Dict of arguments passed in from the client.
|
|
:return: Returns :class:`FollowOnProcessingStatusDTO` if follow-on
|
|
processing (such as retrying this or another task) is
|
|
required, otherwise a None return indicates that no
|
|
follow-on processing is required.
|
|
"""
|
|
try:
|
|
return self.process(*args, **kwargs)
|
|
except Exception:
|
|
LOG.exception("Suppressing exception while trying to "
|
|
"process task '%s'.", self.get_name())
|
|
|
|
def process(self, *args, **kwargs):
|
|
"""A template method for all asynchronous tasks.
|
|
|
|
This method should not be overridden by sub-classes. Rather the
|
|
abstract methods below should be overridden.
|
|
|
|
:param args: List of arguments passed in from the client.
|
|
:param kwargs: Dict of arguments passed in from the client.
|
|
:return: Returns :class:`FollowOnProcessingStatusDTO` if follow-on
|
|
processing (such as retrying this or another task) is
|
|
required, otherwise a None return indicates that no
|
|
follow-on processing is required.
|
|
"""
|
|
name = self.get_name()
|
|
result = None
|
|
|
|
# Retrieve the target entity (such as an models.Order instance).
|
|
try:
|
|
entity = self.retrieve_entity(*args, **kwargs)
|
|
except Exception:
|
|
# Serious error!
|
|
LOG.exception("Could not retrieve information needed to "
|
|
"process task '%s'.", name)
|
|
raise
|
|
|
|
# Process the target entity.
|
|
try:
|
|
result = self.handle_processing(entity, *args, **kwargs)
|
|
except Exception as e_orig:
|
|
LOG.exception("Could not perform processing for task '%s'.", name)
|
|
|
|
# Handle failure to process entity.
|
|
try:
|
|
status, message = api.generate_safe_exception_message(name,
|
|
e_orig)
|
|
self.handle_error(entity, status, message, e_orig,
|
|
*args, **kwargs)
|
|
except Exception:
|
|
LOG.exception("Problem handling an error for task '%s', "
|
|
"raising original exception.", name)
|
|
raise e_orig
|
|
|
|
# Handle successful conclusion of processing.
|
|
try:
|
|
self.handle_success(entity, result, *args, **kwargs)
|
|
except Exception:
|
|
LOG.exception("Could not process after successfully "
|
|
"executing task '%s'.", name)
|
|
raise
|
|
return result
|
|
|
|
@abc.abstractmethod
|
|
def retrieve_entity(self, *args, **kwargs):
|
|
"""A hook method to retrieve an entity for processing.
|
|
|
|
:param args: List of arguments passed in from the client.
|
|
:param kwargs: Dict of arguments passed in from the client.
|
|
:return: Entity instance to process in subsequent hook methods.
|
|
"""
|
|
|
|
@abc.abstractmethod
|
|
def handle_processing(self, entity, *args, **kwargs):
|
|
"""A hook method to handle processing on behalf of an entity.
|
|
|
|
:param args: List of arguments passed in from the client.
|
|
:param kwargs: Dict of arguments passed in from the client.
|
|
:return: None if no follow on processing is needed for this task,
|
|
otherwise a :class:`FollowOnProcessingStatusDTO` instance
|
|
with information on how to process this task into the future.
|
|
"""
|
|
|
|
@abc.abstractmethod
|
|
def handle_error(self, entity, status, message, exception,
|
|
*args, **kwargs):
|
|
"""A hook method to deal with errors seen during processing.
|
|
|
|
This method could be used to mark entity as being in error, and/or
|
|
to record an error cause.
|
|
|
|
:param entity: Entity retrieved from _retrieve_entity() above.
|
|
:param status: Status code for exception.
|
|
:param message: Reason/message for the exception.
|
|
:param exception: Exception raised from handle_processing() above.
|
|
:param args: List of arguments passed in from the client.
|
|
:param kwargs: Dict of arguments passed in from the client.
|
|
:return: None
|
|
"""
|
|
|
|
@abc.abstractmethod
|
|
def handle_success(self, entity, result, *args, **kwargs):
|
|
"""A hook method to post-process after successful entity processing.
|
|
|
|
This method could be used to mark entity as being active, or to
|
|
add information/references to the entity.
|
|
|
|
:param entity: Entity retrieved from _retrieve_entity() above.
|
|
:param result: A :class:`FollowOnProcessingStatusDTO` instance
|
|
representing processing result status, None implies
|
|
that no follow on processing is required.
|
|
:param args: List of arguments passed in from the client.
|
|
:param kwargs: Dict of arguments passed in from the client.
|
|
:return: None
|
|
"""
|
|
|
|
|
|
class _OrderTaskHelper(object):
|
|
"""Supports order-related BaseTask operations.
|
|
|
|
BaseTask sub-classes can delegate to an instance of this class to perform
|
|
common order-related operations.
|
|
"""
|
|
def __init__(self):
|
|
self.order_repo = rep.get_order_repository()
|
|
|
|
def retrieve_entity(self, order_id, external_project_id, *args, **kwargs):
|
|
"""Retrieve an order entity by its PK ID."""
|
|
return self.order_repo.get(
|
|
entity_id=order_id,
|
|
external_project_id=external_project_id)
|
|
|
|
def handle_error(self, order, status, message, exception,
|
|
*args, **kwargs):
|
|
"""Stamp the order entity as terminated due to an error."""
|
|
order.status = models.States.ERROR
|
|
order.error_status_code = status
|
|
order.set_error_reason_safely(message)
|
|
self.order_repo.save(order)
|
|
|
|
def handle_success(self, order, result, *args, **kwargs):
|
|
"""Handle if the order entity is terminated or else long running.
|
|
|
|
The 'result' argument (if present) indicates if a order should now be
|
|
terminated due to it being completed, or else should be held in the
|
|
PENDING state due to follow on workflow processing. If 'result' is not
|
|
provided, the order is presumed completed.
|
|
"""
|
|
is_follow_on_needed = False
|
|
sub_status = None
|
|
sub_status_message = None
|
|
if result:
|
|
is_follow_on_needed = result.is_follow_on_needed()
|
|
sub_status = result.status
|
|
sub_status_message = result.status_message
|
|
|
|
if not is_follow_on_needed:
|
|
order.status = models.States.ACTIVE
|
|
else:
|
|
order.status = models.States.PENDING
|
|
|
|
if sub_status:
|
|
order.set_sub_status_safely(sub_status)
|
|
|
|
if sub_status_message:
|
|
order.set_sub_status_message_safely(sub_status_message)
|
|
|
|
self.order_repo.save(order)
|
|
|
|
|
|
class BeginTypeOrder(BaseTask):
|
|
"""Handles beginning processing of a TypeOrder."""
|
|
|
|
def get_name(self):
|
|
return u._('Process TypeOrder')
|
|
|
|
def __init__(self):
|
|
super(BeginTypeOrder, self).__init__()
|
|
LOG.debug('Creating BeginTypeOrder task processor')
|
|
self.project_repo = rep.get_project_repository()
|
|
self.helper = _OrderTaskHelper()
|
|
|
|
def retrieve_entity(self, *args, **kwargs):
|
|
return self.helper.retrieve_entity(*args, **kwargs)
|
|
|
|
def handle_processing(self, order, *args, **kwargs):
|
|
return self.handle_order(order)
|
|
|
|
def handle_order(self, order):
|
|
"""Handle secret creation using meta info.
|
|
|
|
If type is key
|
|
create secret
|
|
if type is asymmetric
|
|
create secrets
|
|
create containers
|
|
if type is certificate
|
|
TBD
|
|
:param order: Order to process.
|
|
:return: None if no follow on processing is needed for this task,
|
|
otherwise a :class:`FollowOnProcessingStatusDTO` instance
|
|
with information on how to process this task into the future.
|
|
"""
|
|
result_follow_on = common.FollowOnProcessingStatusDTO()
|
|
|
|
order_info = order.to_dict_fields()
|
|
order_type = order_info.get('type')
|
|
meta_info = order_info.get('meta')
|
|
if order_info.get('creator_id'):
|
|
meta_info.setdefault('creator_id', order_info.get('creator_id'))
|
|
|
|
# Retrieve the project.
|
|
project = self.project_repo.get(order.project_id)
|
|
|
|
if order_type == models.OrderType.KEY:
|
|
# Create Secret
|
|
new_secret = plugin.generate_secret(
|
|
meta_info,
|
|
meta_info.get('payload_content_type',
|
|
'application/octet-stream'),
|
|
project
|
|
)
|
|
order.secret_id = new_secret.id
|
|
LOG.debug("...done creating keys order's secret.")
|
|
elif order_type == models.OrderType.ASYMMETRIC:
|
|
# Create asymmetric Secret
|
|
new_container = plugin.generate_asymmetric_secret(
|
|
meta_info,
|
|
meta_info.get('payload_content_type',
|
|
'application/octet-stream'),
|
|
project)
|
|
order.container_id = new_container.id
|
|
LOG.debug("...done creating asymmetric order's secret.")
|
|
else:
|
|
raise NotImplementedError(
|
|
u._('Order type "{order_type}" not implemented.').format(
|
|
order_type=order_type))
|
|
|
|
return result_follow_on
|
|
|
|
def handle_error(self, order, status, message, exception,
|
|
*args, **kwargs):
|
|
self.helper.handle_error(
|
|
order, status, message, exception, *args, **kwargs)
|
|
|
|
def handle_success(self, order, result, *args, **kwargs):
|
|
self.helper.handle_success(
|
|
order, result, *args, **kwargs)
|