class PinpointBackend(BaseBackend):
"""Implementation of Pinpoint APIs."""
def __init__(self, region_name, account_id):
super().__init__(region_name, account_id)
self.apps = {}
self.tagger = TaggingService()
def create_app(self, name, tags):
app = App(name)
self.apps[app.application_id] = app
tags = self.tagger.convert_dict_to_tags_input(tags)
self.tagger.tag_resource(app.arn, tags)
return app
def delete_app(self, application_id):
self.get_app(application_id)
return self.apps.pop(application_id)
def get_app(self, application_id):
if application_id not in self.apps:
raise ApplicationNotFound()
return self.apps[application_id]
def get_apps(self):
"""
Pagination is not yet implemented
"""
return self.apps.values()
def update_application_settings(self, application_id, settings):
app = self.get_app(application_id)
return app.update_settings(settings)
def get_application_settings(self, application_id):
app = self.get_app(application_id)
return app.get_settings()
def list_tags_for_resource(self, resource_arn):
tags = self.tagger.get_tag_dict_for_resource(resource_arn)
return {"tags": tags}
def tag_resource(self, resource_arn, tags):
tags = TaggingService.convert_dict_to_tags_input(tags)
self.tagger.tag_resource(resource_arn, tags)
def untag_resource(self, resource_arn, tag_keys):
self.tagger.untag_resource_using_names(resource_arn, tag_keys)
return
def put_event_stream(self, application_id, stream_arn, role_arn):
app = self.get_app(application_id)
return app.put_event_stream(stream_arn, role_arn)
def get_event_stream(self, application_id):
app = self.get_app(application_id)
return app.get_event_stream()
def delete_event_stream(self, application_id):
app = self.get_app(application_id)
return app.delete_event_stream()
class MQBackend(BaseBackend):
"""
No EC2 integration exists yet - subnet ID's and security group values are not validated. Default values may not exist.
"""
def __init__(self, region_name=None):
self.region_name = region_name
self.brokers = dict()
self.configs = dict()
self.tagger = TaggingService()
def reset(self):
"""Re-initialize all attributes for this instance."""
region_name = self.region_name
self.__dict__ = {}
self.__init__(region_name)
def create_broker(
self,
authentication_strategy,
auto_minor_version_upgrade,
broker_name,
configuration,
deployment_mode,
encryption_options,
engine_type,
engine_version,
host_instance_type,
ldap_server_metadata,
logs,
maintenance_window_start_time,
publicly_accessible,
security_groups,
storage_type,
subnet_ids,
tags,
users,
):
broker = Broker(
name=broker_name,
region=self.region_name,
authentication_strategy=authentication_strategy,
auto_minor_version_upgrade=auto_minor_version_upgrade,
configuration=configuration,
deployment_mode=deployment_mode,
encryption_options=encryption_options,
engine_type=engine_type,
engine_version=engine_version,
host_instance_type=host_instance_type,
ldap_server_metadata=ldap_server_metadata,
logs=logs,
maintenance_window_start_time=maintenance_window_start_time,
publicly_accessible=publicly_accessible,
security_groups=security_groups,
storage_type=storage_type,
subnet_ids=subnet_ids,
users=users,
)
self.brokers[broker.id] = broker
self.create_tags(broker.arn, tags)
return broker.arn, broker.id
def delete_broker(self, broker_id):
del self.brokers[broker_id]
def describe_broker(self, broker_id):
if broker_id not in self.brokers:
raise UnknownBroker(broker_id)
return self.brokers[broker_id]
def reboot_broker(self, broker_id):
self.brokers[broker_id].reboot()
def list_brokers(self):
"""
Pagination is not yet implemented
"""
return self.brokers.values()
def create_user(self, broker_id, username, console_access, groups):
broker = self.describe_broker(broker_id)
broker.create_user(username, console_access, groups)
def update_user(self, broker_id, console_access, groups, username):
broker = self.describe_broker(broker_id)
broker.update_user(username, console_access, groups)
def describe_user(self, broker_id, username):
broker = self.describe_broker(broker_id)
return broker.get_user(username)
def delete_user(self, broker_id, username):
broker = self.describe_broker(broker_id)
broker.delete_user(username)
def list_users(self, broker_id):
broker = self.describe_broker(broker_id)
return broker.list_users()
def create_configuration(self, name, engine_type, engine_version, tags):
if engine_type.upper() == "RABBITMQ":
raise UnsupportedEngineType(engine_type)
if engine_type.upper() != "ACTIVEMQ":
raise UnknownEngineType(engine_type)
config = Configuration(
region=self.region_name,
name=name,
engine_type=engine_type,
engine_version=engine_version,
)
self.configs[config.id] = config
self.tagger.tag_resource(
config.arn, self.tagger.convert_dict_to_tags_input(tags)
)
return config
def update_configuration(self, config_id, data, description):
"""
No validation occurs on the provided XML. The authenticationStrategy may be changed depending on the provided configuration.
"""
config = self.configs[config_id]
config.update(data, description)
return config
def describe_configuration(self, config_id):
if config_id not in self.configs:
raise UnknownConfiguration(config_id)
return self.configs[config_id]
def describe_configuration_revision(self, config_id, revision_id):
config = self.configs[config_id]
return config.get_revision(revision_id)
def list_configurations(self):
"""
Pagination has not yet been implemented.
"""
return self.configs.values()
def create_tags(self, resource_arn, tags):
self.tagger.tag_resource(
resource_arn, self.tagger.convert_dict_to_tags_input(tags)
)
def list_tags(self, arn):
return self.tagger.get_tag_dict_for_resource(arn)
def delete_tags(self, resource_arn, tag_keys):
if not isinstance(tag_keys, list):
tag_keys = [tag_keys]
self.tagger.untag_resource_using_names(resource_arn, tag_keys)
def update_broker(
self,
authentication_strategy,
auto_minor_version_upgrade,
broker_id,
configuration,
engine_version,
host_instance_type,
ldap_server_metadata,
logs,
maintenance_window_start_time,
security_groups,
):
broker = self.describe_broker(broker_id)
broker.update(
authentication_strategy=authentication_strategy,
auto_minor_version_upgrade=auto_minor_version_upgrade,
configuration=configuration,
engine_version=engine_version,
host_instance_type=host_instance_type,
ldap_server_metadata=ldap_server_metadata,
logs=logs,
maintenance_window_start_time=maintenance_window_start_time,
security_groups=security_groups,
)
class AppSyncBackend(BaseBackend):
"""Implementation of AppSync APIs."""
def __init__(self, region_name=None):
self.region_name = region_name
self.graphql_apis = dict()
self.tagger = TaggingService()
def reset(self):
"""Re-initialize all attributes for this instance."""
region_name = self.region_name
self.__dict__ = {}
self.__init__(region_name)
def create_graphql_api(
self,
name,
log_config,
authentication_type,
user_pool_config,
open_id_connect_config,
additional_authentication_providers,
xray_enabled,
lambda_authorizer_config,
tags,
):
graphql_api = GraphqlAPI(
region=self.region_name,
name=name,
authentication_type=authentication_type,
additional_authentication_providers=
additional_authentication_providers,
log_config=log_config,
xray_enabled=xray_enabled,
user_pool_config=user_pool_config,
open_id_connect_config=open_id_connect_config,
lambda_authorizer_config=lambda_authorizer_config,
)
self.graphql_apis[graphql_api.api_id] = graphql_api
self.tagger.tag_resource(
graphql_api.arn, TaggingService.convert_dict_to_tags_input(tags))
return graphql_api
def update_graphql_api(
self,
api_id,
name,
log_config,
authentication_type,
user_pool_config,
open_id_connect_config,
additional_authentication_providers,
xray_enabled,
lambda_authorizer_config,
):
graphql_api = self.graphql_apis[api_id]
graphql_api.update(
name,
additional_authentication_providers,
authentication_type,
lambda_authorizer_config,
log_config,
open_id_connect_config,
user_pool_config,
xray_enabled,
)
return graphql_api
def get_graphql_api(self, api_id):
if api_id not in self.graphql_apis:
raise GraphqlAPINotFound(api_id)
return self.graphql_apis[api_id]
def delete_graphql_api(self, api_id):
self.graphql_apis.pop(api_id)
def list_graphql_apis(self):
"""
Pagination or the maxResults-parameter have not yet been implemented.
"""
return self.graphql_apis.values()
def create_api_key(self, api_id, description, expires):
return self.graphql_apis[api_id].create_api_key(description, expires)
def delete_api_key(self, api_id, api_key_id):
self.graphql_apis[api_id].delete_api_key(api_key_id)
def list_api_keys(self, api_id):
"""
Pagination or the maxResults-parameter have not yet been implemented.
"""
if api_id in self.graphql_apis:
return self.graphql_apis[api_id].list_api_keys()
else:
return []
def update_api_key(self, api_id, api_key_id, description, expires):
return self.graphql_apis[api_id].update_api_key(
api_key_id, description, expires)
def start_schema_creation(self, api_id, definition):
self.graphql_apis[api_id].start_schema_creation(definition)
return "PROCESSING"
def get_schema_creation_status(self, api_id):
return self.graphql_apis[api_id].get_schema_status()
def tag_resource(self, resource_arn, tags):
self.tagger.tag_resource(
resource_arn, TaggingService.convert_dict_to_tags_input(tags))
def untag_resource(self, resource_arn, tag_keys):
self.tagger.untag_resource_using_names(resource_arn, tag_keys)
def list_tags_for_resource(self, resource_arn):
return self.tagger.get_tag_dict_for_resource(resource_arn)
def get_type(self, api_id, type_name, type_format):
return self.graphql_apis[api_id].get_type(type_name, type_format)
