@twilio/conversations 1.3.0-rc7 → 2.0.0-rc.3

package/tools/sdk-release-tool/sdk_release_tools/__main__.py

@@ -1,110 +0,0 @@
-#!/usr/local/bin/python
-from sdk_release_tools import log
-from sdk_release_tools.aws import (get_routing_rules, load_routing_rules,
-                                   update_routing_rules)
-from sdk_release_tools.cli import parse_args
-from sdk_release_tools.util import (delete, download, get_cors, get_pinned_by,
-                                    get_versions, load_schema,
-                                    pin, pin_latest, unpin, unpin_latest,
-                                    upload, version_exists)
-from sdk_release_tools.versions import parse_major_minor, parse_version
-
-
-import sys
-
-
-def main():
-    sys.argv[0] = 'sdk-release-tool'
-    args = parse_args()
-    action = args.action
-    realm = args.realm
-
-    if action == 'delete':
-        schema = load_schema(args.product)
-        version = parse_version(args.version)
-        if not version_exists(realm, schema, version):
-            raise Exception('Version {} does not exist'.format(version))
-        elif get_pinned_by(realm, schema, version) and not args.force:
-            raise Exception(('Cannot delete a pinned version; '
-                             'use -f or --force to override'))
-        delete(realm, schema, version, args.dry_run, args.silent)
-
-    elif action == 'download':
-        schema = load_schema(args.product)
-        version = parse_version(args.version)
-        if not version_exists(realm, schema, args.version):
-            raise Exception('Version {} does not exist'.format(version))
-        download(realm, schema, version, args.destination, args.dry_run)
-
-    elif action == 'list':
-        schema = load_schema(args.product)
-        ordered_versions, _, latest = get_versions(realm, schema)
-        for version, major_minor in ordered_versions.items():
-            line = version
-            if major_minor:
-                line += ' <- {}'.format(major_minor)
-            if str(version) == str(latest):
-                line += ' (latest)'
-            log.log(line)
-
-    elif action == 'list-routing-rules':
-        get_routing_rules(realm)
-        return
-
-    elif action == 'pin':
-        schema = load_schema(args.product)
-        version = parse_version(args.version)
-        if not version_exists(realm, schema, version):
-            raise Exception('Version {} does not exist'.format(version))
-        elif (hasattr(version, 'pre_release') and version.pre_release and
-              not args.force):
-            raise Exception(('Cannot pin a pre-release version; '
-                             'use -f or --force to override'))
-        pin(realm, schema, version, args.dry_run)
-
-    elif action == 'pin-latest':
-        schema = load_schema(args.product)
-        version = parse_version(args.version)
-        _, _, latest_version = get_versions(realm, schema)
-        if not version_exists(realm, schema, version):
-            raise Exception('Version {} does not exist'.format(version))
-        elif (hasattr(version, 'pre_release') and version.pre_release and
-              not args.force):
-            raise Exception(('Cannot pin a pre-release version; '
-                             'use -f or --force to override'))
-        elif (latest_version and version < latest_version and not args.force):
-            raise Exception(('Cannot pin version earlier than latest as next latest; '
-                             'use -f or --force to override'))
-        pin_latest(realm, schema, version, args.dry_run)
-
-    elif action == 'unpin':
-        schema = load_schema(args.product)
-        major_minor = parse_major_minor(args.version)
-        unpin(realm, schema, major_minor, args.dry_run)
-
-    elif action == 'unpin-latest':
-        schema = load_schema(args.product)
-        version = parse_version(args.version)
-        unpin_latest(realm, schema, version, args.dry_run)
-
-    elif action == 'update-routing-rules':
-        routing_rules_xml_file = args.xml
-        routing_rules = load_routing_rules(routing_rules_xml_file)
-        update_routing_rules(realm, routing_rules, args.dry_run)
-        return
-
-    elif action == 'get-cors':
-        get_cors(realm)
-        return
-
-    elif action == 'upload':
-        schema = load_schema(args.product)
-        version = parse_version(args.version)
-        if version_exists(realm, schema, version) and not args.force:
-            raise Exception(('Cannot overwrite an existing version; '
-                             'use -f or --force to override'))
-        upload(realm, schema, version, args.source, args.dry_run)
-
-
-if __name__ == '__main__':
-    main()

package/tools/sdk-release-tool/sdk_release_tools/aws.py

@@ -1,70 +0,0 @@
-from boto.s3.connection import S3Connection, OrdinaryCallingFormat
-
-import json
-import os
-
-
-__all__ = ['get_bucket', 'get_routing_rules', 'update_routing_rules']
-
-
-def get_bucket(environment):
-    """
-    Get the SDK S3 bucket for the given realm, e.g. media.twiliocdn.com. This
-    requires AWS credentials for AWS user cdn-sdki in either a JSON file at the
-    root of this project or in environment variables.
-    """
-    def get_aws_creds(environment, aws_user):
-        if (os.getenv('AWS_' + environment.upper() + '_ACCESS_KEY_ID') and
-                os.getenv('AWS_' + environment.upper() + '_SECRET_ACCESS_KEY')):
-            return (os.getenv('AWS_' + environment.upper() + '_ACCESS_KEY_ID'),
-                    os.getenv('AWS_' + environment.upper() + '_SECRET_ACCESS_KEY'))
-        aws_user_json_path = os.path.join(
-            os.path.dirname(os.path.realpath(__file__)),
-            '../{}.{}.json'.format(aws_user, environment))
-        with open(aws_user_json_path) as aws_user_json_file:
-            aws_user_json = json.loads(aws_user_json_file.read())
-            return (aws_user_json['AccessKeyId'],
-                    aws_user_json['SecretAccessKey'])
-        raise (Exception(
-            'Unable to find AWS credentials for user {} in realm {}'.format(
-                aws_user, environment)))
-
-    def create_s3_conn(environment, aws_user):
-        key_id, secret_key = get_aws_creds(environment, aws_user)
-        return S3Connection(aws_access_key_id=key_id,
-                            aws_secret_access_key=secret_key,
-                            calling_format=OrdinaryCallingFormat())
-
-    conn = create_s3_conn(environment, 'cdn-sdki')
-    bucket_name_prefix = environment
-    if environment == 'prod':
-        bucket_name_prefix = 'media'
-    bucket_name = bucket_name_prefix + '.twiliocdn.com'
-    bucket = conn.get_bucket(bucket_name)
-    return bucket
-
-
-def get_routing_rules(realm):
-    bucket = get_bucket(realm)
-    config = bucket.get_website_configuration_obj()
-    print(config.routing_rules.to_xml())
-
-
-def load_routing_rules(routing_rules_xml_file_path):
-    class ToXML(object):
-        def __init__(self, xml):
-            self.xml = xml
-
-        def to_xml(self):
-            return self.xml
-    with open(routing_rules_xml_file_path) as routing_rules_xml_file:
-        return ToXML(routing_rules_xml_file.read())
-
-
-def update_routing_rules(realm, routing_rules, dry_run=True):
-    bucket = get_bucket(realm)
-    config = bucket.get_website_configuration_obj()
-    if not dry_run:
-        bucket.configure_website(suffix=config.suffix,
-                                 error_key=config.error_key,
-                                 routing_rules=routing_rules)

package/tools/sdk-release-tool/sdk_release_tools/cli.py

@@ -1,181 +0,0 @@
-from argparse import ArgumentParser
-from sdk_release_tools import log
-
-__all__ = ['parse_args']
-
-
-def parse_realms(parser):
-    realm_grp = parser.add_mutually_exclusive_group()
-    for realm in ['dev', 'stage', 'prod']:
-        realm_grp.add_argument('--' + realm, action='store_const',
-                               const=realm, dest='realm',
-                               help=realm + ' realm flag')
-    return parser
-
-
-def parse_dry_run(parser):
-    parser.add_argument('--dry-run', action='store_true', default=False,
-                        dest='dry_run', help='do not perform any updates')
-    return parser
-
-
-def parse_delete_action(parser):
-    parser = parser.add_parser('delete', help=('delete product artifacts at a '
-                                               'version number'))
-    parse_realms(parser)
-    parser.add_argument('product', type=str,
-                        help='the product to delete')
-    parser.add_argument('version', type=str,
-                        help='the version number to delete at, e.g. "1.2.3"')
-    parser.add_argument('-f', '--force', action='store_true', default=False,
-                        help=('force a delete regardless of whether or not '
-                              'the artifact is pinned by a major/minor '
-                              'version'))
-    parser.add_argument('-s', '--silent', action='store_true', default=False, help=('skip user confirmation of files to be deleted'))
-    parse_dry_run(parser)
-    return parser
-
-
-def parse_download_action(parser):
-    parser = parser.add_parser('download', help=('download product artifacts '
-                                                 'from a version number'))
-    parse_realms(parser)
-    parser.add_argument('product', type=str, help='the product to download')
-    parser.add_argument('version', type=str,
-                        help=('the version number to download from, e.g. '
-                              '"1.2.3"; you may also pass a major/minor pair '
-                              'to download the pinned version number, e.g. '
-                              '"v1.0"'))
-    parser.add_argument('destination', type=str,
-                        help=('the directory to download to'))
-    parse_dry_run(parser)
-    return parser
-
-
-def parse_list_action(parser):
-    parser = parser.add_parser('list', help=('list the version numbers of '
-                                             'uploaded product artifacts and '
-                                             'any pinned major/minor pairs'))
-    parse_realms(parser)
-    parser.add_argument('product', type=str, help='the product to list')
-    return parser
-
-
-def parse_list_routing_rules_action(parser):
-    parser = parser.add_parser('list-routing-rules',
-                               help=('list Routing Rules XML'))
-    parse_realms(parser)
-    return parser
-
-
-def parse_pin_action(parser):
-    parser = parser.add_parser('pin', help=('pin a major/minor pair to a '
-                                            'version number'))
-    parse_realms(parser)
-    parser.add_argument('product', type=str, help='the product to pin')
-    parser.add_argument('version', type=str,
-                        help='the version number to pin, e.g. "1.2.3"')
-    parser.add_argument('-f', '--force', action='store_true', default=False,
-                        help=('force a pin regardless of whether or not the '
-                              'version is a pre-release version'))
-    parse_dry_run(parser)
-    return parser
-
-
-def parse_pin_latest_action(parser):
-    parser = parser.add_parser('pin-latest',
-                               help=('pin "latest" to a version number'))
-    parse_realms(parser)
-    parser.add_argument('product', type=str, help='the product to pin')
-    parser.add_argument('version', type=str,
-                        help='the version number to pin, e.g. "1.2.3"')
-    parser.add_argument('-f', '--force', action='store_true', default=False,
-                        help=('force a pin regardless of whether or not the '
-                              'version is a pre-release version'))
-    parse_dry_run(parser)
-    return parser
-
-
-def parse_unpin_action(parser):
-    parser = parser.add_parser('unpin', help=('unpin a major/minor pair from '
-                                              'a version number'))
-    parse_realms(parser)
-    parser.add_argument('product', type=str, help='the product to unpin')
-    parser.add_argument('version', type=str,
-                        help='the major/minor pair to unpin, e.g. "v1.2"')
-    parse_dry_run(parser)
-    return parser
-
-
-def parse_unpin_latest_action(parser):
-    parser = parser.add_parser('unpin-latest',
-                               help=('unpin "latest" from a version number'))
-    parse_realms(parser)
-    parser.add_argument('product', type=str, help='the product to unpin')
-    parser.add_argument('version', type=str,
-                        help='the version number to unpin, e.g. "1.2.3"')
-    parse_dry_run(parser)
-    return parser
-
-
-def parse_upload_action(parser):
-    parser = parser.add_parser('upload', help=('upload product artifacts to '
-                                               'a version number'))
-    parse_realms(parser)
-    parser.add_argument('product', type=str, help='the product to upload')
-    parser.add_argument('version', type=str,
-                        help='the version number to upload to, e.g. "1.2.3"')
-    parser.add_argument('source', type=str,
-                        help='a directory or RPM containing the artifacts')
-    parser.add_argument('-f', '--force', action='store_true', default=False,
-                        help=('force an upload regardless of whether or not '
-                              'the artifact already exists'))
-    parse_dry_run(parser)
-    return parser
-
-def parse_get_cors_action(parser):
-    parser = parser.add_parser('get-cors',
-                               help=('Get the cors settings for the realm'))
-    parse_realms(parser)
-    return parser
-
-
-def parse_update_routing_rules_action(parser):
-    parser = parser.add_parser('update-routing-rules',
-                               help=('manually update Routing Rules '
-                                     '(dangerous)'))
-    parse_realms(parser)
-    parser.add_argument('xml', type=str,
-                        help=('the Routing Rules XML file'))
-    parse_dry_run(parser)
-    return parser
-
-
-def parse_args():
-    parser = ArgumentParser(description=('Manage Twilio SDK releases on the '
-                                         'CDN'))
-
-    action_parser = parser.add_subparsers(help='sub-command help',
-                                          dest='action')
-    parse_delete_action(action_parser)
-    parse_download_action(action_parser)
-    parse_list_action(action_parser)
-    parse_list_routing_rules_action(action_parser)
-    parse_pin_action(action_parser)
-    parse_pin_latest_action(action_parser)
-    parse_unpin_action(action_parser)
-    parse_unpin_latest_action(action_parser)
-    parse_upload_action(action_parser)
-    parse_get_cors_action(action_parser)
-    parse_update_routing_rules_action(action_parser)
-
-    args = parser.parse_args()
-    # if parser.has_errors:
-    #     parser.handle_error()
-    if not hasattr(args, 'realm') or not args.realm:
-        args.realm = 'dev'
-        log.warn('  No realm specified, assuming dev')
-    if not args.action:
-        args.action = 'list'
-
-    return args

package/tools/sdk-release-tool/sdk_release_tools/log.py

@@ -1,24 +0,0 @@
-from clint.textui import colored
-
-import sys
-
-
-def debug(message):
-    print(colored.green(message))
-
-
-def error(message):
-    print(colored.red(message))
-    sys.exit(1)
-
-
-def info(message):
-    print(colored.blue(message))
-
-
-def log(message):
-    print(message)
-
-
-def warn(message):
-    print(colored.yellow(message))

package/tools/sdk-release-tool/sdk_release_tools/ops.py

@@ -1,295 +0,0 @@
-from boto.s3.key import Key
-from sdk_release_tools import log
-from sdk_release_tools.versions import parse_major_minor
-
-import os
-
-__all__ = ['Delete', 'Download', 'Pin', 'Unpin', 'Upload', 'delete',
-           'download', 'pin', 'unpin', 'upload']
-
-
-def absolute(root):
-    if not os.path.isabs(root):
-        root = os.path.join(os.getcwd(), root)
-    return root
-
-
-class Context(object):
-    def __init__(self, root=None, variables=None, bucket=None, dry_run=True, silent=False,
-                 copy_on_pin=False):
-        self.root = root
-        self.variables = variables or {}
-        self.bucket = bucket
-        self.rules = (bucket.get_website_configuration_obj().routing_rules if
-                      bucket else None)
-        self.dry_run = dry_run
-        self.silent = silent
-        self.copy_on_pin = copy_on_pin
-
-    def absolute(self, key):
-        """
-        Get the absolute path to a key prepended by this Context's root, and
-        interpolate any variables.
-        """
-        path = self.relative(key)
-        if self.root:
-            path = os.path.join(self.root, path)
-        return absolute(path)
-
-    def relative(self, key):
-        """
-        Get the relative path to a key, and interpolate any variables.
-        """
-        return key.format(**self.variables)
-
-
-class Ops(object):
-    def __init__(self, tree):
-        self.tree = tree
-
-    def _fold(self, context, tree=None):
-        tree = tree or self.tree
-        for key, value in tree.items():
-            context = self._op(key, value, context)
-        return context
-
-    def _op(self, key, value, context):
-        if key.endswith('/'):
-            return self._op_dir(key, value, context)
-        return self._op_file(key, value, context)
-
-    def _op_dir(self, key, value, context):
-        return context
-
-    def _op_file(self, key, value, context):
-        return context
-
-    def run(self, context):
-        return self._fold(context)
-
-
-class Delete(Ops):
-    def _op_dir(self, key, value, context):
-        src = context.relative(value)
-        for sub_key in context.bucket.list(src):
-            context = self._op_file(sub_key.name, sub_key.name, context)
-        return context
-
-    def _op_file(self, key, value, context):
-        src = context.relative(value)
-        
-        if not context.silent:
-            response =  raw_input("Confirm deletion of " + src + " [y/n]: ").lower()
-            if response == "yes" or response == "y":
-                log.log("  Continuing deletion of: " + src + "\n")
-                self._delete_file(src, context)
-            else:
-                log.log("  Skipping, " + src + " will be protected.\n")
-        else:
-            log.log(src)
-            self._delete_file(src,context)
-        return context
-
-    def _delete_file(self, src, context):
-        src_key = context.bucket.get_key(src)
-        if not src_key:
-            log.warn('  Key {} does not exist'.format(src))
-
-        if not context.dry_run and src_key:
-            context.bucket.delete_key(src)
-            log.log("   " + src + " deleted")
-        return context
-
-
-class Download(Ops):
-    def _op_dir(self, key, value, context):
-        src = context.relative(value)
-        for sub_key in context.bucket.list(src):
-            context = self._op_file(
-                os.path.join(key, sub_key.name[len(src):]), sub_key.name,
-                context)
-        return context
-
-    def _op_file(self, key, value, context):
-        src = context.relative(value)
-        dst = context.absolute(key)
-        log.log('{} -> {}'.format(src, dst))
-
-        src_key = context.bucket.get_key(src)
-        if not src_key:
-            log.error('  Key {} does not exist'.format(src))
-
-        if not context.dry_run and src_key:
-            dst_dir = os.path.dirname(dst)
-            try:
-                os.makedirs(dst_dir)
-            except:
-                pass
-            src_key.get_contents_to_filename(dst)
-
-        return context
-
-
-def reconfigure_website(bucket, rules):
-    config = bucket.get_website_configuration_obj()
-    bucket.configure_website(suffix=config.suffix, error_key=config.error_key,
-                             routing_rules=rules)
-
-
-class Pin(Ops):
-    def _op(self, key, value, context):
-        src = context.relative(key)
-        dst = context.relative(value)
-        log.log('{} -> {}'.format(src, dst))
-
-        # Delete any previous RoutingRules. We have to use S3 Key redirects.
-        for rule in list(context.rules):
-            key_prefix = rule.condition.key_prefix
-            if not src.startswith(key_prefix):
-                continue
-
-            replace_key_prefix = rule.redirect.replace_key_prefix
-
-            try:
-                major_minor = parse_major_minor(
-                    os.path.split(key_prefix.rstrip('/'))[1])
-            except:
-                continue
-
-            if (major_minor != parse_major_minor(
-                    '{major}.{minor}'.format(**context.variables))):
-                continue
-
-            context.rules.remove(rule)
-
-            log.warn('  Deleting RoutingRule that pointed to {}'.format(
-                replace_key_prefix))
-
-        # Create S3 Key redirect.
-        src_key = context.bucket.get_key(src)
-        if not src_key:
-            log.log('  Creating S3 Key redirect')
-        else:
-            existing_redirect = src_key.get_redirect()
-            log.warn('  Updating S3 Key redirect that pointed to {}'.format(
-                existing_redirect))
-
-        if not context.dry_run:
-            if not src_key:
-                src_key = Key(context.bucket)
-                src_key.key = src
-            src_key.set_redirect('/' + dst.lstrip('/'), headers={
-                'Cache-Control': 'max-age=0, no-cache, no-store'
-            })
-
-        return context
-
-    def run(self, context):
-        context = super(Pin, self).run(context)
-        if not context.dry_run:
-            reconfigure_website(context.bucket, context.rules)
-        return context
-
-
-class Unpin(Ops):
-    def _op(self, key, value, context):
-        src = context.relative(key)
-        dst = context.relative(value)
-        log.log('{} -> {}'.format(src, dst))
-
-        found = False
-
-        # Delete any RoutingRules.
-        for rule in list(context.rules):
-            key_prefix = rule.condition.key_prefix
-            if not src.startswith(key_prefix):
-                continue
-
-            replace_key_prefix = rule.redirect.replace_key_prefix
-
-            try:
-                major_minor = parse_major_minor(
-                    os.path.split(key_prefix.rstrip('/'))[1])
-            except:
-                continue
-
-            if (major_minor != parse_major_minor(
-                    '{major}.{minor}'.format(**context.variables))):
-                continue
-
-            found = True
-            context.rules.remove(rule)
-            log.warn('  Deleting RoutingRule that pointed to {}'.format(
-                replace_key_prefix))
-
-        # Delete any S3 Key redirects.
-        src_key = context.bucket.get_key(src)
-        if src_key:
-            found = True
-            if not context.dry_run:
-                context.bucket.delete_key(src)
-
-        if not found:
-            log.warn('  Redirect {} does not exist'.format(src))
-
-        return context
-
-    def run(self, context):
-        context = super(Unpin, self).run(context)
-        if not context.dry_run:
-            reconfigure_website(context.bucket, context.rules)
-        return context
-
-
-class Upload(Ops):
-    def _op_dir(self, key, value, context):
-        srcdir = context.absolute(key)
-
-        for path, _, srcs in os.walk(srcdir):
-            for src in srcs:
-                sub_path = path[len(context.absolute(key)):]
-                sub_key = os.path.join(key, sub_path, src)
-                sub_value = os.path.join(value, sub_path, src)
-                context = self._op_file(sub_key, sub_value, context)
-
-        return context
-
-    def _op_file(self, key, value, context):
-        src = context.absolute(key)
-        dst = context.relative(value)
-        log.log('{} -> {}'.format(src, dst))
-
-        dst_key = context.bucket.get_key(dst)
-        if dst_key:
-            log.warn('  Updating Key')
-
-        if not context.dry_run:
-            if not dst_key:
-                dst_key = Key(context.bucket)
-                dst_key.key = dst
-            dst_key.set_contents_from_filename(src, headers={
-                'Cache-Control': 'max-age=315360000',
-                'Expires': 'Thu, 31 Dec 2037 23:55:55 GMT'
-            })
-
-        return context
-
-
-def delete(tree, **kwargs):
-    return Delete(tree).run(Context(**kwargs))
-
-
-def download(tree, **kwargs):
-    return Download(tree).run(Context(**kwargs))
-
-
-def pin(tree, **kwargs):
-    return Pin(tree).run(Context(**kwargs))
-
-
-def unpin(tree, **kwargs):
-    return Unpin(tree).run(Context(**kwargs))
-
-
-def upload(tree, **kwargs):
-    return Upload(tree).run(Context(**kwargs))