def DeleteDeployment(self, request, context=None):
try:
request.namespace = request.namespace or self.default_namespace
deployment_pb = self.deployment_store.get(request.deployment_name,
request.namespace)
if deployment_pb:
# find deployment operator based on deployment spec
operator = get_deployment_operator(deployment_pb)
# executing deployment deletion
response = operator.delete(deployment_pb, self.repo)
# if delete successful, remove it from active deployment records table
if response.status.status_code == status_pb2.Status.OK:
self.deployment_store.delete(request.deployment_name,
request.namespace)
return response
else:
return DeleteDeploymentResponse(status=Status.NOT_FOUND(
'Deployment "{}" in namespace "{}" not found'.format(
request.deployment_name, request.namespace)))
except BentoMLException as e:
logger.error("INTERNAL ERROR: %s", e)
return DeleteDeploymentResponse(status=Status.INTERNAL(e))
def DescribeDeployment(self, request, context=None):
try:
request.namespace = request.namespace or self.default_namespace
deployment_pb = self.deployment_store.get(
request.deployment_name, request.namespace
)
if deployment_pb:
operator = get_deployment_operator(deployment_pb)
response = operator.describe(deployment_pb, self)
if response.status.status_code == status_pb2.Status.OK:
with self.deployment_store.update_deployment(
request.deployment_name, request.namespace
) as deployment:
deployment.state = ProtoMessageToDict(response.state)
return response
else:
return DescribeDeploymentResponse(
status=Status.NOT_FOUND(
'Deployment "{}" in namespace "{}" not found'.format(
request.deployment_name, request.namespace
)
)
)
except BentoMLException as e:
logger.error("INTERNAL ERROR: %s", e)
return DescribeDeploymentResponse(Status.INTERNAL(str(e)))
def ApplyDeployment(self, request, context=None):
try:
# apply default namespace if not set
request.deployment.namespace = (request.deployment.namespace
or self.default_namespace)
# TODO: validate deployment config
# create or update deployment spec record
self.deployment_store.insert_or_update(request.deployment)
# find deployment operator based on deployment spec
operator = get_deployment_operator(request.deployment)
# deploying to target platform
response = operator.apply(request.deployment, self.repo)
# update deployment state
self.deployment_store.insert_or_update(response.deployment)
return response
except BentoMLException as e:
logger.error("INTERNAL ERROR: %s", e)
return ApplyDeploymentResponse(Status.INTERNAL(e))
def ApplyDeployment(self, request, context=None):
try:
# apply default namespace if not set
request.deployment.namespace = (
request.deployment.namespace or self.default_namespace
)
validation_errors = validate_deployment_pb_schema(request.deployment)
if validation_errors:
return ApplyDeploymentResponse(
status=Status.INVALID_ARGUMENT(
'Failed to validate deployment. {errors}'.format(
errors=validation_errors
)
)
)
previous_deployment = self.deployment_store.get(
request.deployment.name, request.deployment.namespace
)
if previous_deployment:
# check deployment platform
if (
previous_deployment.spec.operator
!= request.deployment.spec.operator
):
return ApplyDeploymentResponse(
status=Status.ABORTED(
'Can not change the target deploy platform of existing '
'active deployment. Try delete existing deployment and '
'deploy to new target platform again'
)
)
request.deployment.state.state = DeploymentState.PENDING
else:
request.deployment.created_at.GetCurrentTime()
request.deployment.last_updated_at.GetCurrentTime()
self.deployment_store.insert_or_update(request.deployment)
# find deployment operator based on deployment spec
operator = get_deployment_operator(request.deployment)
# deploying to target platform
response = operator.apply(request.deployment, self, previous_deployment)
# update deployment state
self.deployment_store.insert_or_update(response.deployment)
return response
except BentoMLException as e:
logger.error("INTERNAL ERROR: %s", e)
return ApplyDeploymentResponse(status=Status.INTERNAL(str(e)))
def ApplyDeployment(self, request, context):
try:
deployment_pb = request.deployment
operator = get_deployment_operator(deployment_pb)
return operator.apply(request)
except BentoMLException:
response = ApplyDeploymentResponse()
# response.status = ...
# LOG.error(....)
return response
def DeleteDeployment(self, request, context=None):
try:
request.namespace = request.namespace or self.default_namespace
deployment_pb = self.deployment_store.get(
request.deployment_name, request.namespace
)
if deployment_pb:
# find deployment operator based on deployment spec
operator = get_deployment_operator(deployment_pb)
# executing deployment deletion
response = operator.delete(deployment_pb, self)
# if delete successful, remove it from active deployment records table
if response.status.status_code == status_pb2.Status.OK:
self.deployment_store.delete(
request.deployment_name, request.namespace
)
return response
# If force delete flag is True, we will remove the record
# from yatai database.
if request.force_delete:
self.deployment_store.delete(
request.deployment_name, request.namespace
)
return DeleteDeploymentResponse(status=Status.OK())
if response.status.status_code == status_pb2.Status.NOT_FOUND:
modified_message = (
'Cloud resources not found, error: {} - it may have been '
'deleted manually. Try delete deployment '
'with "--force" option to ignore this error '
'and force deleting the deployment record'.format(
response.status.error_message
)
)
response.status.error_message = modified_message
return response
else:
return DeleteDeploymentResponse(
status=Status.NOT_FOUND(
'Deployment "{}" in namespace "{}" not found'.format(
request.deployment_name, request.namespace
)
)
)
except BentoMLException as e:
logger.error("INTERNAL ERROR: %s", e)
return DeleteDeploymentResponse(status=Status.INTERNAL(str(e)))
def DeleteDeployment(self, request, context):
try:
deployment_name = request.deployment_name
deployment_pb = self.store.get(deployment_name)
operator = get_deployment_operator(deployment_pb)
return operator.delete(request)
except BentoMLException:
response = DeleteDeploymentResponse()
# response.status = ...
# LOG.error(....)
return response
def ApplyDeployment(self, request, context=None):
try:
# apply default namespace if not set
request.deployment.namespace = (
request.deployment.namespace or self.default_namespace
)
validation_errors = validate_deployment_pb_schema(request.deployment)
if validation_errors:
raise InvalidArgument(
'Failed to validate deployment. {errors}'.format(
errors=validation_errors
)
)
previous_deployment = self.deployment_store.get(
request.deployment.name, request.deployment.namespace
)
if not previous_deployment:
request.deployment.created_at.GetCurrentTime()
request.deployment.last_updated_at.GetCurrentTime()
self.deployment_store.insert_or_update(request.deployment)
# find deployment operator based on deployment spec
operator = get_deployment_operator(self, request.deployment)
# deploying to target platform
if previous_deployment:
response = operator.update(request.deployment, previous_deployment)
else:
response = operator.add(request.deployment)
if response.status.status_code == status_pb2.Status.OK:
# update deployment state
if response and response.deployment:
self.deployment_store.insert_or_update(response.deployment)
else:
raise BentoMLException(
"DeploymentOperator Internal Error: failed to add or update "
"deployment metadata to database"
)
logger.info(
"ApplyDeployment (%s, namespace %s) succeeded",
request.deployment.name,
request.deployment.namespace,
)
else:
if not previous_deployment:
# When failed to create the deployment, delete it from active
# deployments records
self.deployment_store.delete(
request.deployment.name, request.deployment.namespace
)
logger.debug(
"ApplyDeployment (%s, namespace %s) failed: %s",
request.deployment.name,
request.deployment.namespace,
response.status.error_message,
)
return response
except BentoMLException as e:
logger.error("RPC ERROR ApplyDeployment: %s", e)
return ApplyDeploymentResponse(status=e.status_proto)
