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. """ import boto3 from syndicate.commons.log_helper import get_logger from syndicate.connection.helper import apply_methods_decorator, retry _LOG = get_logger('syndicate.connection.application_autoscaling_connection') @apply_methods_decorator(retry) class ApplicationAutoscaling(object): def __init__(self, region=None, aws_access_key_id=None, aws_secret_access_key=None, aws_session_token=None): self.region = region self.aws_access_key_id = aws_access_key_id self.aws_secret_access_key = aws_secret_access_key self.aws_session_token = aws_session_token self.client = boto3.client('application-autoscaling', region,
import sys import yaml from syndicate.commons.log_helper import get_logger from syndicate.core.conf.processor import ( PROJECT_PATH_CFG, LEGACY_CONFIG_FILE_NAME, CONFIG_FILE_NAME, ALIASES_FILE_NAME, ACCOUNT_ID_CFG, REGION_CFG, DEPLOY_TARGET_BUCKET_CFG, AWS_ACCESS_KEY_ID_CFG, AWS_SECRET_ACCESS_KEY_CFG, PROJECTS_MAPPING_CFG, RESOURCES_PREFIX_CFG, RESOURCES_SUFFIX_CFG) from syndicate.core.conf.validator import (PYTHON_BUILD_TOOL_NAME, MVN_BUILD_TOOL_NAME, NODE_BUILD_TOOL_NAME, LAMBDAS_ALIASES_NAME_CFG) _LOG = get_logger('config_generator') def generate_configuration_files(config_path, region, account_id, access_key, secret_key, bundle_bucket_name, python_build_mapping, java_build_mapping, nodejs_build_mapping, prefix, suffix, project_path=None): if not config_path:
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. """ from botocore.exceptions import ClientError from syndicate.commons.log_helper import get_logger from syndicate.connection.helper import retry from syndicate.core import CONFIG, CONN from syndicate.core.helper import create_pool, prettify_json, unpack_kwargs from syndicate.core.resources.helper import (build_description_obj, resolve_dynamic_identifier) _IAM_CONN = CONN.iam() _LOG = get_logger('syndicate.core.resources.iam_resource') def remove_policies(args): create_pool(_remove_policy, args) @unpack_kwargs def _remove_policy(arn, config): policy_name = config['resource_name'] try: _IAM_CONN.remove_policy(arn) _LOG.info('IAM policy %s was removed.', policy_name) except ClientError as e: error_code = e.response['Error']['Code'] if error_code == 'NoSuchEntity':
import sys from concurrent.futures import ALL_COMPLETED, ThreadPoolExecutor from functools import wraps from threading import Thread from time import time from click import BadParameter from tqdm import tqdm from syndicate.commons.log_helper import get_logger from syndicate.core import CONFIG, CONN from syndicate.core.conf.config_holder import path_resolver from syndicate.core.constants import (ARTIFACTS_FOLDER, BUILD_META_FILE_NAME, DEFAULT_SEP) _LOG = get_logger('syndicate.core.helper') def create_pool(func, args, workers=None, *kwargs): """ Create resources in pool in sub processes. :type args: iterable :type func: func """ executor = ThreadPoolExecutor(workers) if workers else ThreadPoolExecutor() try: futures = [executor.submit(func, i, kwargs) for i in args] concurrent.futures.wait(futures, return_when=ALL_COMPLETED) responses = {} for future in futures: result = future.result()
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. """ import time from botocore.exceptions import ClientError from syndicate.commons.log_helper import get_logger from syndicate.core.helper import unpack_kwargs from syndicate.core.resources.base_resource import BaseResource from syndicate.core.resources.helper import build_description_obj _LOG = get_logger('core.resources.sqs_resource') AVAILABLE_REGIONS = [ 'us-east-2', 'us-east-1', 'us-west-1', 'us-west-2', 'ap-south-1', 'ap-northeast-2', 'ap-southeast-1', 'ap-southeast-2', 'ap-northeast-1', 'ca-central-1', 'eu-central-1', 'eu-west-2', 'sa-east-1', 'eu-west-1' ] FIFO_REGIONS = ['us-east-1', 'us-east-2', 'us-west-2', 'eu-west-1'] class SqsResource(BaseResource): def __init__(self, sqs_conn_builder, region, account_id) -> None: self.sqs_conn_builder = sqs_conn_builder self.region = region self.account_id = account_id
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. """ import time from botocore.exceptions import ClientError from syndicate.commons.log_helper import get_logger from syndicate.core.helper import unpack_kwargs from syndicate.core.resources.base_resource import BaseResource from syndicate.core.resources.helper import (build_description_obj, validate_params) _LOG = get_logger('core.resources.step_function_resource') class StepFunctionResource(BaseResource): def __init__(self, sf_conn, iam_conn, cw_events_conn, lambda_conn, account_id, region) -> None: self.sf_conn = sf_conn self.iam_conn = iam_conn self.cw_events_conn = cw_events_conn self.lambda_conn = lambda_conn self.account_id = account_id self.region = region def create_state_machine(self, args): return self.create_pool(self._create_state_machine_from_meta, args)
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. """ from boto3 import client from botocore.exceptions import ClientError from syndicate.commons.log_helper import get_logger from syndicate.connection.helper import apply_methods_decorator, retry _LOG = get_logger('syndicate.connection.api_gateway_connection') @apply_methods_decorator(retry) class ApiGatewayConnection(object): """ API Gateway connection class.""" def __init__(self, region=None, aws_access_key_id=None, aws_secret_access_key=None, aws_session_token=None): self.region = region self.aws_access_key_id = aws_access_key_id self.aws_secret_access_key = aws_secret_access_key self.aws_session_token = aws_session_token self.client = client('apigateway',
import time from botocore.exceptions import ClientError from syndicate.commons.log_helper import get_logger from syndicate.connection.helper import retry from syndicate.core.build.meta_processor import S3_PATH_NAME from syndicate.core.helper import (unpack_kwargs, exit_on_exception) from syndicate.core.resources.base_resource import BaseResource from syndicate.core.resources.helper import (build_description_obj, validate_params, assert_required_params) PROVISIONED_CONCURRENCY = 'provisioned_concurrency' _LOG = get_logger('syndicate.core.resources.lambda_resource') LAMBDA_MAX_CONCURRENCY = 'max_concurrency' LAMBDA_CONCUR_QUALIFIER_ALIAS = 'ALIAS' LAMBDA_CONCUR_QUALIFIER_VERSION = 'VERSION' _LAMBDA_PROV_CONCURRENCY_QUALIFIERS = [ LAMBDA_CONCUR_QUALIFIER_ALIAS, LAMBDA_CONCUR_QUALIFIER_VERSION ] class LambdaResource(BaseResource): def __init__(self, lambda_conn, s3_conn, cw_logs_conn, sns_conn, iam_conn, dynamodb_conn, sqs_conn, kinesis_conn, cw_events_conn, region, account_id, deploy_target_bucket) -> None: self.lambda_conn = lambda_conn self.s3_conn = s3_conn
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. """ import time from syndicate.commons.log_helper import get_logger from syndicate.core import ClientError from syndicate.core.helper import unpack_kwargs from syndicate.core.resources.base_resource import BaseResource from syndicate.core.resources.helper import build_description_obj _LOG = get_logger('syndicate.core.resources.kinesis_resource') class KinesisResource(BaseResource): def __init__(self, kin_conn) -> None: self.kin_conn = kin_conn def create_kinesis_stream(self, args): return self.create_pool(self._create_kinesis_stream_from_meta, args) def remove_kinesis_streams(self, args): self.create_pool(self._remove_kinesis_stream, args) @unpack_kwargs def _remove_kinesis_stream(self, arn, config): stream_name = config['resource_name']
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. """ import json import uuid from json import dumps from boto3 import client from botocore.exceptions import ClientError from syndicate.commons.log_helper import get_logger from syndicate.connection.helper import apply_methods_decorator, retry _LOG = get_logger('syndicate.connection.cloud_watch_connection') @apply_methods_decorator(retry) class LogsConnection(object): """ CloudWatch Log connection class.""" def __init__(self, region=None, aws_access_key_id=None, aws_secret_access_key=None, aws_session_token=None): self.client = client('logs', region, aws_access_key_id=aws_access_key_id, aws_secret_access_key=aws_secret_access_key, aws_session_token=aws_session_token)
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. """ from boto3 import client from syndicate.commons.log_helper import get_logger from syndicate.connection.helper import apply_methods_decorator, retry from syndicate.connection.iam_connection import IAMConnection _LOG = get_logger('syndicate.connection.cognito_identity_connection') @apply_methods_decorator(retry) class CognitoIdentityConnection(object): """ Cognito identity connection class.""" def __init__(self, region=None, aws_access_key_id=None, aws_secret_access_key=None, aws_session_token=None): self.region = region, self.aws_access_key_id = aws_access_key_id self.aws_secret_access_key = aws_secret_access_key self.aws_session_token = aws_session_token self.client = client('cognito-identity',
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. """ import os import sys from botocore.exceptions import ClientError from botocore.vendored.requests.packages import urllib3 from syndicate.commons.log_helper import get_logger from syndicate.connection import ConnectionProvider from syndicate.connection.sts_connection import STSConnection from syndicate.core.conf.config_holder import ConfigHolder _LOG = get_logger('deployment.__init__') S3_PATH_NAME = 's3_path' SESSION_TOKEN = 'aws_session_token' SECRET_KEY = 'aws_secret_access_key' ACCESS_KEY = 'aws_access_key_id' def exception_handler(exception_type, exception, traceback): print(exception) sys.excepthook = exception_handler # suppress botocore warnings urllib3.disable_warnings()
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. """ from boto3 import client from botocore.waiter import WaiterModel, create_waiter_with_client from syndicate.commons.log_helper import get_logger from syndicate.connection.helper import apply_methods_decorator, retry from syndicate.core.helper import dict_keys_to_camel_case _LOG = get_logger('syndicate.connection.batch_connection') @apply_methods_decorator(retry) class BatchConnection(object): """ AWS Batch connection class. """ def __init__(self, region=None, aws_access_key_id=None, aws_secret_access_key=None, aws_session_token=None): self.client = client('batch', region, aws_access_key_id=aws_access_key_id, aws_secret_access_key=aws_secret_access_key, aws_session_token=aws_session_token) _LOG.debug('Opened new Batch connection.') def create_compute_environment(self, compute_environment_name,
from syndicate.commons.log_helper import get_logger from syndicate.core.generators import (_touch, _mkdir, _write_content_to_file, FILE_LAMBDA_HANDLER_PYTHON, FILE_LAMBDA_HANDLER_NODEJS, _read_content_from_file) from syndicate.core.generators.contents import ( NODEJS_LAMBDA_HANDLER_TEMPLATE, PYTHON_LAMBDA_HANDLER_TEMPLATE, _generate_python_node_lambda_config, _generate_lambda_role_config, _generate_nodejs_node_lambda_config, CANCEL_MESSAGE, _generate_package_nodejs_lambda, _generate_package_lock_nodejs_lambda, JAVA_LAMBDA_HANDLER_CLASS, SRC_MAIN_JAVA, FILE_POM) from syndicate.core.groups import (PROJECT_JAVA, PROJECT_NODEJS, PROJECT_PYTHON) _LOG = get_logger('syndicate.core.generators.lambda_function') SLASH_SYMBOL = '/' FOLDER_LAMBDAS = '/lambdas' FOLDER_COMMONS = '/commons' FILE_README = '/README.md' FILE_DEPLOYMENT_RESOURCES = '/deployment_resources.json' FILE_INIT_PYTHON = '/__init__.py' FILE_LAMBDA_CONFIG = '/lambda_config.json' FILE_PACKAGE_LOCK = '/package-lock.json' FILE_PACKAGE = '/package.json' FILE_REQUIREMENTS = '/requirements.txt' FILE_LOCAL_REQUIREMENTS = '/local_requirements.txt'
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. """ import traceback from functools import wraps from time import sleep from botocore.exceptions import ClientError from syndicate.commons.log_helper import get_logger _LOG = get_logger('syndicate.connection.helper') def apply_methods_decorator(decorator): def decorate(cls): for attr in cls.__dict__: if callable(getattr(cls, attr)): setattr(cls, attr, decorator(getattr(cls, attr))) return cls return decorate def retry(handler_func): """ Decorator for retry on specified exceptions.
from concurrent.futures import ThreadPoolExecutor from botocore.exceptions import ClientError from syndicate.commons.log_helper import get_logger from syndicate.connection import S3Connection from syndicate.core import CONFIG, CONN, sts from syndicate.core.build.helper import _json_serial from syndicate.core.build.meta_processor import validate_deployment_packages from syndicate.core.constants import (ARTIFACTS_FOLDER, BUILD_META_FILE_NAME, DEFAULT_SEP) from syndicate.core.helper import build_path, unpack_kwargs _S3_CONN = CONN.s3() _LOG = get_logger('syndicate.core.build.bundle_processor') def _build_output_key(bundle_name, deploy_name, is_regular_output): return '{0}/outputs/{1}{2}.json'.format( bundle_name, deploy_name, '' if is_regular_output else '_failed') def _backup_deploy_output(filename, output): _LOG.info('Wrote file to {0}'.format(filename)) with open(filename, 'a+') as backup_file: backup_file.write(output) backup_file.close() def create_deploy_output(bundle_name,
from syndicate.core.build.validator.mapping import (VALIDATOR_BY_TYPE_MAPPING, ALL_TYPES) from syndicate.core.conf.config_holder import GLOBAL_AWS_SERVICES from syndicate.core.constants import (API_GATEWAY_TYPE, ARTIFACTS_FOLDER, BUILD_META_FILE_NAME, EBS_TYPE, LAMBDA_CONFIG_FILE_NAME, LAMBDA_TYPE, RESOURCES_FILE_NAME, RESOURCE_LIST, IAM_ROLE, LAMBDA_LAYER_TYPE) from syndicate.core.helper import (build_path, prettify_json, resolve_aliases_for_string, write_content_to_file) from syndicate.core.resources.helper import resolve_dynamic_identifier DEFAULT_IAM_SUFFIX_LENGTH = 5 _LOG = get_logger('syndicate.core.build.meta_processor') def validate_deployment_packages(meta_resources): package_paths = artifact_paths(meta_resources) bundles_path = build_path(CONFIG.project_path, ARTIFACTS_FOLDER) nonexistent_packages = [] for package in package_paths: package_path = build_path(bundles_path, package) if not os.path.exists(package_path): nonexistent_packages.append(package_path) if nonexistent_packages: raise AssertionError('Bundle is not properly configured.' ' Nonexistent deployment packages: ' '{0}'.format(prettify_json(nonexistent_packages)))
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. """ from botocore.waiter import WaiterError from syndicate.commons.log_helper import get_logger from syndicate.core.helper import unpack_kwargs from syndicate.core.resources.base_resource import BaseResource from syndicate.core.resources.helper import build_description_obj _LOG = get_logger('syndicate.core.resources.batch_compenv') DEFAULT_STATE = 'ENABLED' DEFAULT_SERVICE_ROLE = 'AWSBatchServiceRole' class BatchComputeEnvironmentResource(BaseResource): def __init__(self, batch_conn, iam_conn): self.batch_conn = batch_conn self.iam_conn = iam_conn def create_compute_environment(self, args): return self.create_pool(self._create_compute_environment_from_meta, args) def describe_compute_environment(self, name, meta):
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. """ import os from syndicate.commons.log_helper import get_logger from syndicate.core.generators import (_touch, _mkdir, _write_content_to_file) from syndicate.core.generators.contents import (_get_lambda_default_policy, JAVA_ROOT_POM_TEMPLATE, SRC_MAIN_JAVA, FILE_POM) from syndicate.core.groups import (PROJECT_JAVA, PROJECT_NODEJS, PROJECT_PYTHON) _LOG = get_logger('syndicate.core.generators.project') SLASH_SYMBOL = '/' FOLDER_LAMBDAS = '/lambdas' FOLDER_COMMONS = '/commons' FILE_README = '/README.md' FILE_DEPLOYMENT_RESOURCES = '/deployment_resources.json' def generate_project_structure(project_name, project_path, project_language): try: if not os.path.exists(project_path): raise AssertionError( 'Path "{}" you have provided does not exist'.format( project_path))
from syndicate.core.build.runtime.java import assemble_java_mvn_lambdas from syndicate.core.build.runtime.nodejs import assemble_node_lambdas from syndicate.core.build.runtime.python import assemble_python_lambdas RUNTIME_JAVA_8 = 'java8' RUNTIME_NODEJS = 'nodejs10.x' RUNTIME_PYTHON = 'pythonX' SUPPORTED_RUNTIMES = [RUNTIME_JAVA_8, RUNTIME_NODEJS, RUNTIME_PYTHON] RUNTIME_TO_BUILDER_MAPPING = { RUNTIME_JAVA_8: assemble_java_mvn_lambdas, RUNTIME_NODEJS: assemble_node_lambdas, RUNTIME_PYTHON: assemble_python_lambdas } _LOG = get_logger('syndicate.core.build.artifact_processor') def assemble_artifacts(bundle_name, project_path, runtime): if runtime not in SUPPORTED_RUNTIMES: raise AssertionError('Runtime {} is not supported. ' 'Currently available runtimes:{}'.format( runtime, SUPPORTED_RUNTIMES)) assemble_func = RUNTIME_TO_BUILDER_MAPPING.get(runtime) if not assemble_func: raise AssertionError( 'There is no assembler for the runtime {}'.format(runtime)) assemble_func(bundle_name=bundle_name, project_path=project_path)
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. """ from boto3 import client from syndicate.commons.log_helper import get_logger from syndicate.connection.helper import apply_methods_decorator, retry _LOG = get_logger('syndicate.connection.secrets_manager_connection') @apply_methods_decorator(retry) class SecretsManagerConnection(object): def __init__(self, region=None, aws_access_key_id=None, aws_secret_access_key=None, aws_session_token=None): self.client = client('secretsmanager', region, aws_access_key_id=aws_access_key_id, aws_secret_access_key=aws_secret_access_key, aws_session_token=aws_session_token) _LOG.debug('Opened new Secrets Manager connection.') def describe_secret(self, secret_id): response = self.client.describe_secret(SecretId=secret_id) return response
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. """ from botocore.exceptions import ClientError from syndicate.commons.log_helper import get_logger from syndicate.core.helper import unpack_kwargs from syndicate.core.resources.base_resource import BaseResource from syndicate.core.resources.helper import build_description_obj _LOG = get_logger('syndicate.core.resources.cognito_identity_resource') class CognitoResource(BaseResource): def __init__(self, cognito_conn, account_id, region) -> None: self.connection = cognito_conn self.account_id = account_id self.region = region def cognito_resource_identifier(self, name, output=None): if output: # cognito currently is not located in different regions # process only first object pool_output = list(output.items())[0][1] # find id from the output
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. """ import os from configobj import ConfigObj from validate import Validator, VdtTypeError from syndicate.commons.log_helper import get_logger from syndicate.core.constants import (DEFAULT_SEP, IAM_POLICY, IAM_ROLE, S3_BUCKET_TYPE) CONFIG_FILE_NAME = 'sdct.conf' _LOG = get_logger('core.conf.config_holder') ALL_REGIONS = [ 'us-east-1', 'us-east-2', 'us-west-1', 'us-west-2', 'sa-east-1', 'ca-central-1', 'eu-west-1', 'eu-central-1', 'eu-west-2', 'eu-west-3', 'ap-northeast-1', 'ap-northeast-2', 'ap-southeast-1', 'ap-southeast-2', 'ap-south-1' ] GLOBAL_AWS_SERVICES = {IAM_ROLE, IAM_POLICY, S3_BUCKET_TYPE} PYTHON_BUILD_TOOL_NAME = 'python' MVN_BUILD_TOOL_NAME = 'mvn' ALLOWED_BUILDS = [PYTHON_BUILD_TOOL_NAME, MVN_BUILD_TOOL_NAME]
See the License for the specific language governing permissions and limitations under the License. """ import time from botocore.exceptions import ClientError from syndicate.commons.log_helper import get_logger from syndicate.core import CONFIG, CONN from syndicate.core.conf.config_holder import ALL_REGIONS from syndicate.core.helper import create_pool, unpack_kwargs from syndicate.core.resources.helper import (build_description_obj, create_args_for_multi_region, validate_params) _LOG = get_logger('syndicate.core.resources.cloud_watch_resource') def describe_rule(name, meta, region, response=None): if not response: response = CONN.cw_events(region).get_rule(name) arn = response['Arn'] del response['Arn'] return {arn: build_description_obj(response, name, meta)} def describe_rule_from_meta(name, meta): new_region_args = create_args_for_multi_region( [ {'name': name, 'meta': meta}
""" import time from botocore.exceptions import ClientError from syndicate.commons.log_helper import get_logger from syndicate.core import CONFIG, CONN from syndicate.core.helper import create_pool, unpack_kwargs from syndicate.core.resources.helper import (build_description_obj, validate_params) from syndicate.core.resources.lambda_resource import ( resolve_lambda_arn_by_version_and_alias) SUPPORTED_METHODS = ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS', 'HEAD'] _LOG = get_logger('syndicate.core.resources.api_gateway_resource') _DEFAULT_RESPONSES = { "responses": [ { "status_code": "200" }, { "status_code": "400" }, { "status_code": "401" }, { "status_code": "403" },
from syndicate.commons.log_helper import get_logger from syndicate.core.build.bundle_processor import ( create_deploy_output, load_deploy_output, load_failed_deploy_output, load_meta_resources, remove_deploy_output, remove_failed_deploy_output) from syndicate.core.build.meta_processor import resolve_meta from syndicate.core.constants import (BUILD_META_FILE_NAME, CLEAN_RESOURCE_TYPE_PRIORITY, DEPLOY_RESOURCE_TYPE_PRIORITY, LAMBDA_TYPE) from syndicate.core.helper import exit_on_exception, prettify_json from syndicate.core.resources import (APPLY_MAPPING, CREATE_RESOURCE, DESCRIBE_RESOURCE, REMOVE_RESOURCE, RESOURCE_CONFIGURATION_PROCESSORS, RESOURCE_IDENTIFIER, UPDATE_RESOURCE) _LOG = get_logger('syndicate.core.build.deployment_processor') def get_dependencies(name, meta, resources_dict, resources): """ Get dependencies from resources that needed to create them too. :type name: str :type meta: dict :type resources_dict: dict :param resources: :param resources_dict: resources that will be created {name: meta} """ resources_dict[name] = meta if meta.get('dependencies'): for dependency in meta.get('dependencies'): dep_name = dependency['resource_name']
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. """ from operator import itemgetter from boto3 import client, resource from boto3.dynamodb.conditions import Attr, Key from botocore.exceptions import ClientError from syndicate.commons.log_helper import get_logger from syndicate.connection.helper import apply_methods_decorator, retry _LOG = get_logger('syndicate.connection.dynamo_connection') def _append_attr_definition(definition, attr_name, attr_type): """ Adds an attribute definition if it is not already present. Dynamodb table creation requires to define attributes that are keys for the table or indexes. There must be no duplicated attribute definitions - aws throws ValidationException in such case. :type definition: [] :type attr_name: str :type attr_type: str """ for each in definition: if each['AttributeName'] == attr_name: return # attribute is already defined, must not duplicate
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. """ from botocore.exceptions import ClientError from syndicate.commons.log_helper import get_logger from syndicate.core import CONN from syndicate.core.resources.alarm_resource import remove_alarms from syndicate.core.resources.helper import (build_description_obj, validate_params) _LOG = get_logger('syndicate.core.resources.dynamo_db_resource') _DYNAMO_DB_CONN = CONN.dynamodb() _CW_METRIC = CONN.cw_metric() _APP_AS_CONN = CONN.application_autoscaling() def create_tables_by_10(args): """ Only 10 tables can be created, updated or deleted simultaneously. :type args: list """ response = dict() waiters = {} start = 0 end = 8 while start < len(args):
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. """ from boto3 import client from syndicate.commons.log_helper import get_logger from syndicate.connection.helper import apply_methods_decorator, retry _LOG = get_logger('syndicate.connection.ses_connection') @apply_methods_decorator(retry) class SESConnection(object): """SES connection class.""" def __init__(self, region=None, aws_access_key_id=None, aws_secret_access_key=None, source_arn=None, aws_session_token=None): self.client = client('ses', region, aws_access_key_id=aws_access_key_id, aws_secret_access_key=aws_secret_access_key, aws_session_token=aws_session_token) self.charset = 'utf-8' self.arn = source_arn
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. """ from json import dumps from boto3 import client from botocore.exceptions import ClientError from syndicate.commons.log_helper import get_logger from syndicate.connection.helper import apply_methods_decorator, retry _LOG = get_logger('syndicate.connection.step_functions_connection') @apply_methods_decorator(retry) class SFConnection(object): """ STS connection class.""" def __init__(self, region=None, aws_access_key_id=None, aws_secret_access_key=None, aws_session_token=None): self.client = client('stepfunctions', region, aws_access_key_id=aws_access_key_id, aws_secret_access_key=aws_secret_access_key, aws_session_token=aws_session_token)