def list(self, request):
log = NarukoLogging(request)
logger = log.get_logger(__name__)
logger.info("START: list")
tenants = ControlTenantUseCase(log).fetch_tenants(request.user)
logger.info("END: list")
return Response(data={"tenants": [TenantModelDetailSerializer(tenant).data for tenant in tenants]})
def update(self, request, pk=None):
log = NarukoLogging(request)
logger = log.get_logger(__name__)
logger.info("START: update")
try:
with transaction.atomic():
# バリデーション
target_tenant = TenantModel.objects.get(pk=pk)
serializer = TenantModelSerializer(instance=target_tenant,
data=request.data)
serializer.is_valid(raise_exception=True)
# 更新
tenant = ControlTenantUseCase(log).update_tenant(
request.user, serializer.save())
data = TenantModelSerializer(tenant).data
except (TypeError, ValueError, KeyError) as e:
# リクエストデータが不正
logger.exception(e)
return Response(status=status.HTTP_400_BAD_REQUEST)
except TenantModel.DoesNotExist as e:
# テナントが存在しない
logger.exception(e)
return Response(status=status.HTTP_404_NOT_FOUND)
except Exception as e:
logger.exception(e)
raise
else:
# 成功
logger.info("END: update")
return Response(data=data, status=status.HTTP_200_OK)
def list(self,
request,
tenant_pk=None,
aws_env_pk=None,
region_pk=None,
service_pk=None,
resource_pk=None):
log = NarukoLogging(request)
logger = log.get_logger(__name__)
logger.info("START: list")
try:
aws_environment = AwsEnvironmentModel.objects.get(
id=aws_env_pk, tenant_id=tenant_pk)
resource = Resource.get_service_resource(region_pk, service_pk,
resource_pk)
backups = ControlResourceUseCase(log).fetch_backups(
request.user, aws_environment, resource)
except (TypeError, ValueError, KeyError, ClientError,
NarukoException) as e:
# リクエストデータが不正
logger.exception(e)
return Response(status=status.HTTP_400_BAD_REQUEST)
except ObjectDoesNotExist as e:
# AWS環境が存在しない
logger.exception(e)
return Response(status=status.HTTP_404_NOT_FOUND)
except Exception as e:
logger.exception(e)
raise
else:
logger.info("END: list")
return Response(data=[backup.serialize() for backup in backups],
status=status.HTTP_200_OK)
def create(self, request):
log = NarukoLogging(request)
logger = log.get_logger(__name__)
logger.info("START: create")
# バリデーション：Company
tenant_serializer = TenantModelSerializer(data=request.data["tenant"])
tenant_serializer.is_valid(raise_exception=True)
tenant_serializer_save = tenant_serializer.save()
# バリデーション：User
data_user = request.data["user"]
data_user["tenant"] = tenant_serializer_save.id
data_user["role"] = RoleModel.ADMIN_ID
user_serializer = UserModelSerializer(data=data_user)
user_serializer.is_valid(raise_exception=True)
user_serializer_save = user_serializer.save()
# 作成
tenant, user = ControlTenantUseCase(log).create_tenant(
request.user,
tenant_serializer_save,
user_serializer_save
)
logger.info("END: create")
return Response(
data={
"tenant": TenantModelDetailSerializer(tenant).data,
"user": UserModelDetailSerializer(user).data
},
status=status.HTTP_201_CREATED)
def reset_password(request):
log = NarukoLogging(request)
logger = log.get_logger(__name__)
logger.info("START: reset password")
try:
data = request.data
user = UserModel.objects.get(email=data["email"])
serializer = ResetPasswordSerializer(
instance=user,
data=data)
serializer.is_valid(raise_exception=True)
user = ResetPasswordUseCase(log).reset_password(user)
except (TypeError, ValueError, KeyError, NarukoException) as e:
# リクエストデータが不正
logger.exception(e)
return Response(status=status.HTTP_400_BAD_REQUEST)
except ObjectDoesNotExist as e:
# ユーザーが存在しない
logger.exception(e)
return Response(status=status.HTTP_404_NOT_FOUND)
except Exception as e:
logger.exception(e)
raise
else:
logger.info("END: reset password")
return Response(data=UserModelDetailSerializer(user).data, status=status.HTTP_200_OK)
def event_execute(request: Request):
log = NarukoLogging(request)
logger = log.get_logger(__name__)
logger.info("START: event_execute")
# リクエストがSNSからであるかを検証する
use_case = ControlEventUseCase(log)
body_data = json.loads(request.body)
logger.info(body_data)
use_case.verify_sns_notification(body_data)
# SNSの種別ごとに分岐
sns_type = body_data.get("Type")
logger.info("Message Type is {}.".format(sns_type))
if sns_type == "Notification":
# 通知：アラームの内容に従って通知処理を実施する
message = json.loads(body_data["Message"])
event = EventRepository.get(message["id"])
use_case.execute(event)
elif sns_type == "SubscriptionConfirmation":
# 購読開始：SNSトピック登録時に初期検証を実施する
use_case.confirm_subscription(body_data)
elif sns_type == "UnsubscribeConfirmation":
# 購読解除：SNSトピック購読解除
logger.info("UnsubscribeConfirmation. {}".format(body_data["Message"]))
else:
# 存在しない種別
logger.warning("UnknownSnsMessageType.")
logger.warning(body_data)
logger.info("END: event_execute")
return Response(status=status.HTTP_200_OK)
def create(self,
request,
tenant_pk=None,
aws_env_pk=None,
region_pk=None,
service_pk=None,
resource_pk=None):
log = NarukoLogging(request)
logger = log.get_logger(__name__)
logger.info("START: create")
try:
aws_environment = AwsEnvironmentModel.objects.get(
id=aws_env_pk, tenant_id=tenant_pk)
resource = Resource.get_service_resource(region_pk, service_pk,
resource_pk)
no_reboot = request.data["no_reboot"] if isinstance(resource,
Ec2) else None
backup_id = ControlResourceUseCase(log).create_backup(
request.user, aws_environment, resource, no_reboot)
except (TypeError, ValueError, KeyError, ClientError,
NarukoException) as e:
# リクエストデータが不正
logger.exception(e)
return Response(status=status.HTTP_400_BAD_REQUEST)
except ObjectDoesNotExist as e:
# AWS環境が存在しない
logger.exception(e)
return Response(status=status.HTTP_404_NOT_FOUND)
except Exception as e:
logger.exception(e)
raise
else:
logger.info("END: create")
return Response(data={"backup_id": backup_id},
status=status.HTTP_201_CREATED)
def create(self, request, tenant_pk=None, detail=True):
log = NarukoLogging(request)
logger = log.get_logger(__name__)
logger.info("START: create")
try:
with transaction.atomic():
# バリデーション
data = request.data
data["tenant"] = tenant_pk
serializer = UserModelSerializer(data=data)
serializer.is_valid(raise_exception=True)
# 作成
user = ControlUserUseCase(log).create_user(
request.user, serializer.save(),
AwsEnvironmentModel.objects.filter(
id__in=data["aws_environments"]), data["password"])
except (TypeError, ValueError, KeyError, NarukoException) as e:
# リクエストデータが不正
logger.exception(e)
return Response(status=status.HTTP_400_BAD_REQUEST)
except ObjectDoesNotExist as e:
logger.exception(e)
# ロールまたはテナントが存在しない
return Response(status=status.HTTP_404_NOT_FOUND)
except Exception as e:
logger.exception(e)
raise
else:
# 成功
print(user)
print(UserModelDetailSerializer(user))
logger.info("END: create")
return Response(data=UserModelDetailSerializer(user).data,
status=status.HTTP_201_CREATED)
def retrieve(self,
request,
tenant_pk=None,
aws_env_pk=None,
region_pk=None,
service_pk=None,
pk=None):
log = NarukoLogging(request)
logger = log.get_logger(__name__)
logger.info("START: retrieve")
try:
aws_environment = AwsEnvironmentModel.objects.get(
id=aws_env_pk, tenant_id=tenant_pk)
resource = ControlResourceUseCase(log).describe_resource(
request.user, aws_environment,
Resource.get_service_resource(region_pk, service_pk, pk))
except (TypeError, ValueError, KeyError, NarukoException) as e:
# リクエストデータが不正
logger.exception(e)
return Response(status=status.HTTP_400_BAD_REQUEST)
except ObjectDoesNotExist as e:
# AWS環境が存在しない
logger.exception(e)
return Response(status=status.HTTP_404_NOT_FOUND)
except Exception as e:
logger.exception(e)
raise
else:
logger.info("END: retrieve")
return Response(data=resource.serialize(aws_environment),
status=status.HTTP_200_OK)
def update(self, request, tenant_pk=None, aws_env_pk=None,
region_pk=None, service_pk=None, resource_pk=None, pk=None):
log = NarukoLogging(request)
logger = log.get_logger(__name__)
logger.info("START: update")
try:
with transaction.atomic():
tenant = TenantModel.objects.get(id=tenant_pk)
aws_env = AwsEnvironmentModel.objects.get(id=aws_env_pk, tenant=tenant)
schedule = ScheduleFactory.create(
resource_id=resource_pk,
service=service_pk,
region=region_pk,
aws_id=aws_env_pk,
event_id=pk,
**request.data)
create_schedule = ControlScheduleUseCase(log).save_schedule(request.user, tenant, aws_env, schedule)
except (TypeError, ValueError, KeyError, ClientError, NarukoException) as e:
# リクエストデータが不正
logger.exception(e)
return Response(status=status.HTTP_400_BAD_REQUEST)
except ObjectDoesNotExist as e:
# AWS環境が存在しない
logger.exception(e)
return Response(status=status.HTTP_404_NOT_FOUND)
except Exception as e:
logger.exception(e)
raise
else:
logger.info("END: update")
return Response(data=create_schedule.serialize(), status=status.HTTP_201_CREATED)
def create(self, request, tenant_pk=None):
log = NarukoLogging(request)
logger = log.get_logger(__name__)
logger.info("START: create")
try:
with transaction.atomic():
# バリデーション
data_dest = request.data
data_dest["tenant"] = tenant_pk
dest_serializer = get_serializer(data_dest)
dest_serializer.is_valid(raise_exception=True)
# 作成
destination = ControlNotificationUseCase(
log).create_destination(request.user,
dest_serializer.save())
data = serialize_destination(destination)
except (TypeError, ValueError, TenantModel.DoesNotExist) as e:
logger.exception(e)
return Response(status=status.HTTP_404_NOT_FOUND)
except Exception as e:
logger.exception(e)
raise
else:
logger.info("END: create")
return Response(data=data, status=status.HTTP_201_CREATED)
def graph(self,
request,
tenant_pk=None,
aws_env_pk=None,
region_pk=None,
service_pk=None,
resource_pk=None,
pk=None):
log = NarukoLogging(request)
logger = log.get_logger(__name__)
logger.info("START: graph")
try:
aws_environment = AwsEnvironmentModel.objects.get(
id=aws_env_pk, tenant_id=tenant_pk)
resource = Resource.get_service_resource(region_pk, service_pk,
resource_pk)
monitor_graph = MonitorGraph(metric_name=pk, **request.data)
monitor_graph = ControlMonitorUseCase(log).graph(
request.user, resource, aws_environment, monitor_graph)
except (TypeError, ValueError, KeyError, NarukoException) as e:
# リクエストデータが不正
logger.exception(e)
return Response(status=status.HTTP_400_BAD_REQUEST)
except ObjectDoesNotExist as e:
# AWS環境が存在しない
logger.exception(e)
return Response(status=status.HTTP_404_NOT_FOUND)
except Exception as e:
logger.exception(e)
raise
else:
logger.info("END: graph")
return Response(data=monitor_graph.serialize(),
status=status.HTTP_200_OK)
def list(self, request, tenant_pk=None):
log = NarukoLogging(request)
logger = log.get_logger(__name__)
logger.info("START: list")
tenant = TenantModel.objects.get(id=tenant_pk)
logs = ControlOperationLog(log).fetch_logs(request.user, tenant)
logger.info("END: list")
return Response(data=[OperationLogModelSerializerDetail(operation_log).data for operation_log in logs])
def destroy(self, request, pk=None):
log = NarukoLogging(request)
logger = log.get_logger(__name__)
logger.info("START: destroy")
tenant = TenantModel.objects.get(id=int(pk))
ControlTenantUseCase(log).delete_tenant(request.user, tenant)
logger.info("END: destroy")
return Response(status=status.HTTP_204_NO_CONTENT)
def destroy(self, request, pk=None, tenant_pk=None):
log = NarukoLogging(request)
logger = log.get_logger(__name__)
logger.info("START: destroy")
target_user = UserModel.objects.get(id=pk, tenant_id=tenant_pk)
ControlUserUseCase(log).delete_user(request.user, target_user)
logger.info("END: destroy")
return Response(status=status.HTTP_204_NO_CONTENT)
def destroy(self, request, tenant_pk=None, pk=None):
log = NarukoLogging(request)
logger = log.get_logger(__name__)
logger.info("START: destroy")
model = AwsEnvironmentModel.objects.get(id=pk, tenant_id=tenant_pk)
ControlAwsEnvironment(log).delete_aws_environment(request.user, model)
logger.info("END: destroy")
return Response(status=status.HTTP_204_NO_CONTENT)
def stop(self, request, tenant_pk=None, aws_env_pk=None,
region_pk=None, service_pk=None, pk=None):
log = NarukoLogging(request)
logger = log.get_logger(__name__)
logger.info("START: stop")
aws_environment = AwsEnvironmentModel.objects.get(id=aws_env_pk, tenant_id=tenant_pk)
resource = Resource.get_service_resource(region_pk, service_pk, pk)
ControlResourceUseCase(log).stop_resource(request.user, aws_environment, resource)
logger.info("END: stop")
return Response(status=status.HTTP_200_OK)
def billing(self, request, tenant_pk=None, pk=None):
log = NarukoLogging(request)
logger = log.get_logger(__name__)
logger.info("START: billing")
aws_environment = AwsEnvironmentModel.objects.get(id=pk,
tenant_id=tenant_pk)
billing_graph = ControlAwsEnvironment(log).billing_graph(
request.user, aws_environment, **request.data)
logger.info("END: billing")
return Response(data=billing_graph, status=status.HTTP_200_OK)
def list(self, request, tenant_pk=None, detail=True):
log = NarukoLogging(request)
logger = log.get_logger(__name__)
logger.info("START: list")
tenant = TenantModel.objects.get(id=tenant_pk)
users = ControlUserUseCase(log).fetch_users(request.user, tenant)
logger.info("END: list")
return Response(data={
"users": [UserModelDetailSerializer(user).data for user in users]
})
def list(self, request, tenant_pk=None, aws_env_pk=None, region_pk=None):
log = NarukoLogging(request)
logger = log.get_logger(__name__)
logger.info("START: list")
aws_environment = AwsEnvironmentModel.objects.get(id=aws_env_pk,
tenant_id=tenant_pk)
documents = ControlResourceUseCase(log).fetch_documents(
request.user, aws_environment, region_pk)
logger.info("END: list")
return Response(data=[doc.serialize() for doc in documents],
status=status.HTTP_200_OK)
def naruko_exception_handler(exc, context):
response = exception_handler(exc, context)
logger = NarukoLogging(context['request']).get_logger(
context['view'].__module__)
logger.exception(exc)
for code in EXCEPTIONS.keys():
if isinstance_in(exc, EXCEPTIONS[code]):
return Response(status=code)
return response
def retrieve(self, request, tenant_pk=None, aws_env_pk=None,
region_pk=None, service_pk=None, pk=None):
log = NarukoLogging(request)
logger = log.get_logger(__name__)
logger.info("START: retrieve")
aws_environment = AwsEnvironmentModel.objects.get(id=aws_env_pk, tenant_id=tenant_pk)
resource = ControlResourceUseCase(log).describe_resource(
request.user,
aws_environment,
Resource.get_service_resource(region_pk, service_pk, pk))
logger.info("END: retrieve")
return Response(data=resource.serialize(aws_environment),
status=status.HTTP_200_OK)
def reset_password(request):
log = NarukoLogging(request)
logger = log.get_logger(__name__)
logger.info("START: reset password")
data = request.data
user = UserModel.objects.get(email=data["email"])
serializer = ResetPasswordSerializer(instance=user, data=data)
serializer.is_valid(raise_exception=True)
user = ResetPasswordUseCase(log).reset_password(user)
logger.info("END: reset password")
return Response(data=UserModelDetailSerializer(user).data,
status=status.HTTP_200_OK)
def create(self, request, tenant_pk=None):
log = NarukoLogging(request)
logger = log.get_logger(__name__)
logger.info("START: create")
request.data['tenant'] = tenant_pk
create_serializer = AwsEnvironmentModelCreateSerializer(
data=request.data)
create_serializer.is_valid(raise_exception=True)
model = create_serializer.save()
ControlAwsEnvironment(log).save_aws_environment(request.user, model)
data = AwsEnvironmentModelGetDetailSerializer(model).data
logger.info("END: create")
return Response(data=data, status=status.HTTP_201_CREATED)
def update(self, request, pk=None):
log = NarukoLogging(request)
logger = log.get_logger(__name__)
logger.info("START: update")
# バリデーション
target_tenant = TenantModel.objects.get(pk=pk)
serializer = TenantModelSerializer(instance=target_tenant, data=request.data)
serializer.is_valid(raise_exception=True)
# 更新
tenant = ControlTenantUseCase(log).update_tenant(request.user, serializer.save())
data = TenantModelSerializer(tenant).data
logger.info("END: update")
return Response(data=data, status=status.HTTP_200_OK)
def list(self, request, tenant_pk=None, aws_env_pk=None):
log = NarukoLogging(request)
logger = log.get_logger(__name__)
logger.info("START: list")
region = request.GET.get("region")
aws_environment = AwsEnvironmentModel.objects.get(id=aws_env_pk, tenant_id=tenant_pk)
resources = ControlResourceUseCase(log).fetch_resources(
request.user,
aws_environment,
region
)
logger.info("END: list")
return Response(data=[resource.serialize(aws_environment) for resource in resources],
status=status.HTTP_200_OK)
def list(self, request, tenant_pk=None, detail=True):
log = NarukoLogging(request)
logger = log.get_logger(__name__)
logger.info("START: list")
tenant = TenantModel.objects.get(id=tenant_pk)
aws_environments = ControlAwsEnvironment(log).fetch_aws_environments(
request.user, tenant)
return Response(
data={
"aws_environments": [
AwsEnvironmentModelGetDetailSerializer(
aws_environment).data
for aws_environment in aws_environments
]
})
def run_command(self, request, tenant_pk=None, aws_env_pk=None,
region_pk=None, service_pk=None, pk=None):
log = NarukoLogging(request)
logger = log.get_logger(__name__)
logger.info("START: run_command")
aws_environment = AwsEnvironmentModel.objects.get(id=aws_env_pk, tenant_id=tenant_pk)
resource = Resource.get_service_resource(region_pk, service_pk, pk)
command = Command(
Document(
request.data["name"],
[Parameter(**param) for param in request.data["parameters"]]),
resource)
command = ControlResourceUseCase(log).run_command(request.user, aws_environment, command)
logger.info("END: run_command")
return Response(status=status.HTTP_200_OK, data=command.serialize())
def update(self, request, tenant_pk=None, pk=None):
log = NarukoLogging(request)
logger = log.get_logger(__name__)
logger.info("START: update")
model = AwsEnvironmentModel.objects.get(id=pk, tenant_id=tenant_pk)
serializer = AwsEnvironmentModelUpdateSerializer(instance=model,
data=request.data,
partial=True)
serializer.is_valid(raise_exception=True)
updated_model = serializer.save()
ControlAwsEnvironment(log).save_aws_environment(
request.user, updated_model)
data = AwsEnvironmentModelGetDetailSerializer(updated_model).data
logger.info("END: update")
return Response(data=data, status=status.HTTP_200_OK)
def create(self, request, tenant_pk=None, detail=True):
log = NarukoLogging(request)
logger = log.get_logger(__name__)
logger.info("START: create")
# バリデーション
data = request.data
data["tenant"] = tenant_pk
serializer = UserModelSerializer(data=data)
serializer.is_valid(raise_exception=True)
# 作成
user = ControlUserUseCase(log).create_user(
request.user, serializer.save(),
AwsEnvironmentModel.objects.filter(
id__in=data["aws_environments"]), data["password"])
logger.info("END: create")
return Response(data=UserModelDetailSerializer(user).data,
status=status.HTTP_201_CREATED)