def logs(args): """`conduct logs` command""" log = logging.getLogger(__name__) request_url = conduct_url.url('bundles/{}/logs?count={}'.format(quote_plus(args.bundle), args.lines), args) # At the time when this comment is being written, we need to pass the Host header when making HTTP request due to # a bug with requests python library not working properly when IPv6 address is supplied: # https://github.com/kennethreitz/requests/issues/3002 # The workaround for this problem is to explicitly set the Host header when making HTTP request. # This fix is benign and backward compatible as the library would do this when making HTTP request anyway. response = requests.get(request_url, timeout=DEFAULT_HTTP_TIMEOUT, headers=conduct_url.request_headers(args)) validation.raise_for_status_inc_3xx(response) data = [ { 'time': validation.format_timestamp(event['timestamp'], args), 'host': event['host'], 'log': event['message'] } for event in json.loads(response.text) ] data.insert(0, {'time': 'TIME', 'host': 'HOST', 'log': 'LOG'}) padding = 2 column_widths = dict(screen_utils.calc_column_widths(data), **{'padding': ' ' * padding}) for row in data: log.screen('''\ {time: <{time_width}}{padding}\ {host: <{host_width}}{padding}\ {log: <{log_width}}{padding}'''.format(**dict(row, **column_widths)).rstrip()) return True
def unload(args): """`conduct unload` command""" log = logging.getLogger(__name__) path = 'bundles/{}'.format(args.bundle) url = conduct_url.url(path, args) response = conduct_request.delete(args.dcos_mode, conductr_host(args), url, auth=args.conductr_auth, verify=args.server_verification_file, timeout=DEFAULT_HTTP_TIMEOUT) validation.raise_for_status_inc_3xx(response) if log.is_verbose_enabled(): log.verbose(validation.pretty_json(response.text)) log.info('Bundle unload request sent.') response_json = json.loads(response.text) if not args.no_wait: bundle_installation.wait_for_uninstallation(response_json['bundleId'], args) if not args.disable_instructions: log.info('Print ConductR info with: {} info{}'.format(args.command, args.cli_parameters)) if not log.is_info_enabled() and log.is_quiet_enabled(): log.quiet(response_json['bundleId']) return True
def logs(args): """`conduct logs` command""" log = logging.getLogger(__name__) request_url = conduct_url.url( 'bundles/{}/logs?count={}'.format(quote_plus(args.bundle), args.lines), args) # At the time when this comment is being written, we need to pass the Host header when making HTTP request due to # a bug with requests python library not working properly when IPv6 address is supplied: # https://github.com/kennethreitz/requests/issues/3002 # The workaround for this problem is to explicitly set the Host header when making HTTP request. # This fix is benign and backward compatible as the library would do this when making HTTP request anyway. response = requests.get(request_url, timeout=DEFAULT_HTTP_TIMEOUT, headers=conduct_url.request_headers(args)) validation.raise_for_status_inc_3xx(response) data = [{ 'time': validation.format_timestamp(event['timestamp'], args), 'host': event['host'], 'log': event['message'] } for event in json.loads(response.text)] data.insert(0, {'time': 'TIME', 'host': 'HOST', 'log': 'LOG'}) padding = 2 column_widths = dict(screen_utils.calc_column_widths(data), **{'padding': ' ' * padding}) for row in data: log.screen('''\ {time: <{time_width}}{padding}\ {host: <{host_width}}{padding}\ {log: <{log_width}}{padding}'''.format(**dict(row, **column_widths)).rstrip()) return True
def services(args): """`conduct services` command""" log = logging.getLogger(__name__) url = conduct_url.url('bundles', args) # At the time when this comment is being written, we need to pass the Host header when making HTTP request due to # a bug with requests python library not working properly when IPv6 address is supplied: # https://github.com/kennethreitz/requests/issues/3002 # The workaround for this problem is to explicitly set the Host header when making HTTP request. # This fix is benign and backward compatible as the library would do this when making HTTP request anyway. response = requests.get(url, timeout=DEFAULT_HTTP_TIMEOUT, headers=conduct_url.request_headers(args)) validation.raise_for_status_inc_3xx(response) if log.is_verbose_enabled(): log.verbose(validation.pretty_json(response.text)) data = sorted([ ( { 'service': service, 'bundle_id': bundle['bundleId'] if args.long_ids else bundle_utils.short_id( bundle['bundleId']), 'bundle_name': bundle['attributes']['bundleName'], 'status': 'Running' if execution['isStarted'] else 'Starting' } ) for bundle in json.loads(response.text) for execution in bundle['bundleExecutions'] for endpoint_name, endpoint in bundle['bundleConfig']['endpoints'].items() if 'services' in endpoint for service in endpoint['services'] ], key=lambda line: line['service']) service_endpoints = {} for service in data: url = urlparse(service['service']) if not (url.path == '' or url.path == '/'): try: service_endpoints[url.path] |= {service['service']} except KeyError: service_endpoints[url.path] = {service['service']} duplicate_endpoints = [service for (service, endpoint) in service_endpoints.items() if len(endpoint) > 1] \ if len(service_endpoints) > 0 else [] data.insert(0, {'service': 'SERVICE', 'bundle_id': 'BUNDLE ID', 'bundle_name': 'BUNDLE NAME', 'status': 'STATUS'}) padding = 2 column_widths = dict(screen_utils.calc_column_widths(data), **{'padding': ' ' * padding}) for row in data: log.screen( '{service: <{service_width}}{padding}' '{bundle_id: <{bundle_id_width}}{padding}' '{bundle_name: <{bundle_name_width}}{padding}' '{status: <{status_width}}'.format(**dict(row, **column_widths)).rstrip()) if len(duplicate_endpoints) > 0: log.screen('') log.warning('Multiple endpoints found for the following services: {}'.format(', '.join(duplicate_endpoints))) log.warning('Service resolution for these services is undefined.') return True
def stop(args): """`conduct stop` command""" log = logging.getLogger(__name__) path = "bundles/{}?scale=0".format(args.bundle) url = conduct_url.url(path, args) response = conduct_request.put( args.dcos_mode, conductr_host(args), url, auth=args.conductr_auth, verify=args.server_verification_file, timeout=DEFAULT_HTTP_TIMEOUT, ) validation.raise_for_status_inc_3xx(response) if log.is_verbose_enabled(): log.verbose(validation.pretty_json(response.text)) response_json = json.loads(response.text) bundle_id = response_json["bundleId"] if args.long_ids else bundle_utils.short_id(response_json["bundleId"]) log.info("Bundle stop request sent.") if not args.no_wait: bundle_scale.wait_for_scale(response_json["bundleId"], 0, args) if not args.disable_instructions: log.info("Unload bundle with: {} unload{} {}".format(args.command, args.cli_parameters, bundle_id)) log.info("Print ConductR info with: {} info{}".format(args.command, args.cli_parameters)) return True
def run(args): """`conduct run` command""" log = logging.getLogger(__name__) if args.affinity is not None and args.api_version == '1': log.error('Affinity feature is only available for v1.1 onwards of ConductR') return elif args.affinity is not None: path = 'bundles/{}?scale={}&affinity={}'.format(args.bundle, args.scale, args.affinity) else: path = 'bundles/{}?scale={}'.format(args.bundle, args.scale) url = conduct_url.url(path, args) response = requests.put(url) validation.raise_for_status_inc_3xx(response) if log.is_verbose_enabled(): log.verbose(validation.pretty_json(response.text)) response_json = json.loads(response.text) bundle_id = response_json['bundleId'] if args.long_ids else bundle_utils.short_id(response_json['bundleId']) log.info('Bundle run request sent.') if not args.no_wait: bundle_scale.wait_for_scale(response_json['bundleId'], args.scale, args) log.info('Stop bundle with: conduct stop{} {}'.format(args.cli_parameters, bundle_id)) log.info('Print ConductR info with: conduct info{}'.format(args.cli_parameters)) return True
def unload(args): """`conduct unload` command""" log = logging.getLogger(__name__) path = 'bundles/{}'.format(args.bundle) url = conduct_url.url(path, args) # At the time when this comment is being written, we need to pass the Host header when making HTTP request due to # a bug with requests python library not working properly when IPv6 address is supplied: # https://github.com/kennethreitz/requests/issues/3002 # The workaround for this problem is to explicitly set the Host header when making HTTP request. # This fix is benign and backward compatible as the library would do this when making HTTP request anyway. response = requests.delete(url, timeout=DEFAULT_HTTP_TIMEOUT, headers=conduct_url.request_headers(args)) validation.raise_for_status_inc_3xx(response) if log.is_verbose_enabled(): log.verbose(validation.pretty_json(response.text)) log.info('Bundle unload request sent.') response_json = json.loads(response.text) if not args.no_wait: bundle_installation.wait_for_uninstallation(response_json['bundleId'], args) log.info('Print ConductR info with: conduct info{}'.format( args.cli_parameters)) if not log.is_info_enabled() and log.is_quiet_enabled(): log.quiet(response_json['bundleId']) return True
def stop(args): """`conduct stop` command""" log = logging.getLogger(__name__) path = 'bundles/{}?scale=0'.format(args.bundle) url = conduct_url.url(path, args) # At the time when this comment is being written, we need to pass the Host header when making HTTP request due to # a bug with requests python library not working properly when IPv6 address is supplied: # https://github.com/kennethreitz/requests/issues/3002 # The workaround for this problem is to explicitly set the Host header when making HTTP request. # This fix is benign and backward compatible as the library would do this when making HTTP request anyway. response = requests.put(url, timeout=DEFAULT_HTTP_TIMEOUT, headers=conduct_url.request_headers(args)) validation.raise_for_status_inc_3xx(response) if log.is_verbose_enabled(): log.verbose(validation.pretty_json(response.text)) response_json = json.loads(response.text) bundle_id = response_json['bundleId'] if args.long_ids else bundle_utils.short_id(response_json['bundleId']) log.info('Bundle stop request sent.') if not args.no_wait: bundle_scale.wait_for_scale(response_json['bundleId'], 0, args) log.info('Unload bundle with: conduct unload{} {}'.format(args.cli_parameters, bundle_id)) log.info('Print ConductR info with: conduct info{}'.format(args.cli_parameters)) return True
def events(args): """`conduct events` command""" log = logging.getLogger(__name__) request_url = conduct_url.url('bundles/{}/events?count={}'.format(quote_plus(args.bundle), args.lines), args) response = conduct_request.get(args.dcos_mode, conductr_host(args), request_url, auth=args.conductr_auth, verify=args.server_verification_file, timeout=DEFAULT_HTTP_TIMEOUT) validation.raise_for_status_inc_3xx(response) data = [ { 'time': validation.format_timestamp(event['timestamp'], args), 'event': event['event'], 'description': event['description'] } for event in json.loads(response.text) ] data.insert(0, {'time': 'TIME', 'event': 'EVENT', 'description': 'DESC'}) padding = 2 column_widths = dict(screen_utils.calc_column_widths(data), **{'padding': ' ' * padding}) for row in data: log.screen('''\ {time: <{time_width}}{padding}\ {event: <{event_width}}{padding}\ {description: <{description_width}}{padding}'''.format(**dict(row, **column_widths)).rstrip()) return True
def events(args): """`conduct events` command""" log = logging.getLogger(__name__) request_url = conduct_url.url( 'bundles/{}/events?count={}'.format(quote_plus(args.bundle), args.lines), args) response = conduct_request.get(args.dcos_mode, conductr_host(args), request_url, auth=args.conductr_auth, verify=args.server_verification_file, timeout=DEFAULT_HTTP_TIMEOUT) validation.raise_for_status_inc_3xx(response) data = [{ 'time': validation.format_timestamp(event['timestamp'], args), 'event': event['event'], 'description': event['description'] } for event in json.loads(response.text)] data.insert(0, {'time': 'TIME', 'event': 'EVENT', 'description': 'DESC'}) padding = 2 column_widths = dict(screen_utils.calc_column_widths(data), **{'padding': ' ' * padding}) for row in data: log.screen('''\ {time: <{time_width}}{padding}\ {event: <{event_width}}{padding}\ {description: <{description_width}}{padding}'''.format( **dict(row, **column_widths)).rstrip()) return True
def unload(args): """`conduct unload` command""" log = logging.getLogger(__name__) path = 'bundles/{}'.format(args.bundle) url = conduct_url.url(path, args) response = conduct_request.delete(args.dcos_mode, conductr_host(args), url, auth=args.conductr_auth, verify=args.server_verification_file, timeout=DEFAULT_HTTP_TIMEOUT) validation.raise_for_status_inc_3xx(response) if log.is_verbose_enabled(): log.verbose(validation.pretty_json(response.text)) log.info('Bundle unload request sent.') response_json = json.loads(response.text) if not args.no_wait: bundle_installation.wait_for_uninstallation(response_json['bundleId'], args) if not args.disable_instructions: log.info('Print ConductR info with: {} info{}'.format( args.command, args.cli_parameters)) if not log.is_info_enabled() and log.is_quiet_enabled(): log.quiet(response_json['bundleId']) return True
def stop(args): """`conduct stop` command""" log = logging.getLogger(__name__) path = 'bundles/{}?scale=0'.format(args.bundle) url = conduct_url.url(path, args) response = conduct_request.put(args.dcos_mode, conductr_host(args), url, auth=args.conductr_auth, verify=args.server_verification_file, timeout=DEFAULT_HTTP_TIMEOUT) validation.raise_for_status_inc_3xx(response) if log.is_verbose_enabled(): log.verbose(validation.pretty_json(response.text)) response_json = json.loads(response.text) bundle_id = response_json[ 'bundleId'] if args.long_ids else bundle_utils.short_id( response_json['bundleId']) log.info('Bundle stop request sent.') if not args.no_wait: bundle_scale.wait_for_scale(response_json['bundleId'], 0, args) if not args.disable_instructions: log.info('Unload bundle with: {} unload{} {}'.format( args.command, args.cli_parameters, bundle_id)) log.info('Print ConductR info with: {} info{}'.format( args.command, args.cli_parameters)) return True
def acls(args): """`conduct acls` command""" log = logging.getLogger(__name__) url = conduct_url.url('bundles', args) response = conduct_request.get(args.dcos_mode, conductr_host(args), url, timeout=DEFAULT_HTTP_TIMEOUT) validation.raise_for_status_inc_3xx(response) if log.is_verbose_enabled(): log.verbose(validation.pretty_json(response.text)) def get_system_version(bundle): if 'systemVersion' in bundle['attributes']: return bundle['attributes']['systemVersion'] else: return bundle['attributes']['system'].split('-')[-1] def is_started(bundle_executions): for execution in bundle_executions: if execution['isStarted']: return 'Running' return 'Starting' all_acls = [{ 'acl': acl, 'system': bundle['attributes']['system'], 'system_version': get_system_version(bundle), 'endpoint_name': endpoint_name, 'bundle_id': bundle['bundleId'] if args.long_ids else bundle_utils.short_id(bundle['bundleId']), 'bundle_name': bundle['attributes']['bundleName'], 'status': is_started(bundle['bundleExecutions']) } for bundle in json.loads(response.text) if bundle['bundleExecutions'] for endpoint_name, endpoint in bundle['bundleConfig'] ['endpoints'].items() if 'acls' in endpoint for acl in endpoint['acls']] if args.protocol_family == 'http': http_acls = [acl for acl in all_acls if 'http' in acl['acl']] display_http_acls(log, http_acls) elif args.protocol_family == 'tcp': tcp_acls = [acl for acl in all_acls if 'tcp' in acl['acl']] display_tcp_acls(log, tcp_acls) return True
def services(args): """`conduct services` command""" log = logging.getLogger(__name__) url = conduct_url.url('bundles', args) response = requests.get(url, timeout=DEFAULT_HTTP_TIMEOUT) validation.raise_for_status_inc_3xx(response) if log.is_verbose_enabled(): log.verbose(validation.pretty_json(response.text)) data = sorted([ ( { 'service': service, 'bundle_id': bundle['bundleId'] if args.long_ids else bundle_utils.short_id( bundle['bundleId']), 'bundle_name': bundle['attributes']['bundleName'], 'status': 'Running' if execution['isStarted'] else 'Starting' } ) for bundle in json.loads(response.text) for execution in bundle['bundleExecutions'] for endpoint_name, endpoint in bundle['bundleConfig']['endpoints'].items() for service in endpoint['services'] ], key=lambda line: line['service']) service_endpoints = {} for service in data: url = urlparse(service['service']) if not (url.path == '' or url.path == '/'): try: service_endpoints[url.path] |= {service['service']} except KeyError: service_endpoints[url.path] = {service['service']} duplicate_endpoints = [service for (service, endpoint) in service_endpoints.items() if len(endpoint) > 1] \ if len(service_endpoints) > 0 else [] data.insert(0, {'service': 'SERVICE', 'bundle_id': 'BUNDLE ID', 'bundle_name': 'BUNDLE NAME', 'status': 'STATUS'}) padding = 2 column_widths = dict(screen_utils.calc_column_widths(data), **{'padding': ' ' * padding}) for row in data: log.screen( '{service: <{service_width}}{padding}' '{bundle_id: <{bundle_id_width}}{padding}' '{bundle_name: <{bundle_name_width}}{padding}' '{status: <{status_width}}'.format(**dict(row, **column_widths)).rstrip()) if len(duplicate_endpoints) > 0: log.screen('') log.warning('Multiple endpoints found for the following services: {}'.format(', '.join(duplicate_endpoints))) log.warning('Service resolution for these services is undefined.') return True
def acls(args): """`conduct acls` command""" log = logging.getLogger(__name__) url = conduct_url.url('bundles', args) # At the time when this comment is being written, we need to pass the Host header when making HTTP request due to # a bug with requests python library not working properly when IPv6 address is supplied: # https://github.com/kennethreitz/requests/issues/3002 # The workaround for this problem is to explicitly set the Host header when making HTTP request. # This fix is benign and backward compatible as the library would do this when making HTTP request anyway. response = requests.get(url, timeout=DEFAULT_HTTP_TIMEOUT, headers=conduct_url.request_headers(args)) validation.raise_for_status_inc_3xx(response) if log.is_verbose_enabled(): log.verbose(validation.pretty_json(response.text)) def get_system_version(bundle): if 'systemVersion' in bundle['attributes']: return bundle['attributes']['systemVersion'] else: return bundle['attributes']['system'].split('-')[-1] all_acls = [{ 'acl': acl, 'system': bundle['attributes']['system'], 'system_version': get_system_version(bundle), 'endpoint_name': endpoint_name, 'bundle_id': bundle['bundleId'] if args.long_ids else bundle_utils.short_id(bundle['bundleId']), 'bundle_name': bundle['attributes']['bundleName'], 'status': 'Running' if execution['isStarted'] else 'Starting' } for bundle in json.loads(response.text) for execution in bundle['bundleExecutions'] for endpoint_name, endpoint in bundle['bundleConfig']['endpoints'].items() if 'acls' in endpoint for acl in endpoint['acls']] if args.protocol_family == 'http': http_acls = [acl for acl in all_acls if 'http' in acl['acl']] display_http_acls(log, http_acls) elif args.protocol_family == 'tcp': tcp_acls = [acl for acl in all_acls if 'tcp' in acl['acl']] display_tcp_acls(log, tcp_acls) return True
def info(args): """`conduct info` command""" log = logging.getLogger(__name__) url = conduct_url.url("bundles", args) response = conduct_request.get( args.dcos_mode, conductr_host(args), url, auth=args.conductr_auth, verify=args.server_verification_file, timeout=DEFAULT_HTTP_TIMEOUT, ) validation.raise_for_status_inc_3xx(response) if log.is_verbose_enabled(): log.verbose(validation.pretty_json(response.text)) data = [ { "id": ("! " if bundle.get("hasError", False) else "") + (bundle["bundleId"] if args.long_ids else bundle_utils.short_id(bundle["bundleId"])), "name": bundle["attributes"]["bundleName"], "replications": len(bundle["bundleInstallations"]), "starting": sum([not execution["isStarted"] for execution in bundle["bundleExecutions"]]), "executions": sum([execution["isStarted"] for execution in bundle["bundleExecutions"]]), } for bundle in json.loads(response.text) ] data.insert(0, {"id": "ID", "name": "NAME", "replications": "#REP", "starting": "#STR", "executions": "#RUN"}) padding = 2 column_widths = dict(screen_utils.calc_column_widths(data), **{"padding": " " * padding}) has_error = False for row in data: has_error |= "!" in row["id"] log.screen( """\ {id: <{id_width}}{padding}\ {name: <{name_width}}{padding}\ {replications: >{replications_width}}{padding}\ {starting: >{starting_width}}{padding}\ {executions: >{executions_width}}""".format( **dict(row, **column_widths) ).rstrip() ) if has_error: log.screen("There are errors: use `conduct events` or `conduct logs` for further information") return True
def load_v2(args): log = logging.getLogger(__name__) log.info('Retrieving bundle...') custom_settings = args.custom_settings resolve_cache_dir = args.resolve_cache_dir bundle_name, bundle_file = resolver.resolve_bundle(custom_settings, resolve_cache_dir, args.bundle) bundle_conf = bundle_utils.zip_entry('bundle.conf', bundle_file) if bundle_conf is None: raise MalformedBundleError('Unable to find bundle.conf within the bundle file') else: configuration_name, configuration_file, bundle_conf_overlay = (None, None, None) if args.configuration is not None: log.info('Retrieving configuration...') configuration_name, configuration_file = resolver.resolve_bundle(custom_settings, resolve_cache_dir, args.configuration) bundle_conf_overlay = bundle_utils.zip_entry('bundle.conf', configuration_file) files = [('bundleConf', ('bundle.conf', bundle_conf))] if bundle_conf_overlay is not None: files.append(('bundleConfOverlay', ('bundle.conf', bundle_conf_overlay))) files.append(('bundle', (bundle_name, open(bundle_file, 'rb')))) if configuration_file is not None: files.append(('configuration', (configuration_name, open(configuration_file, 'rb')))) url = conduct_url.url('bundles', args) log.info('Loading bundle to ConductR...') response = requests.post(url, files=files, timeout=LOAD_HTTP_TIMEOUT) validation.raise_for_status_inc_3xx(response) if log.is_verbose_enabled(): log.verbose(validation.pretty_json(response.text)) response_json = json.loads(response.text) bundle_id = response_json['bundleId'] if args.long_ids else bundle_utils.short_id(response_json['bundleId']) if not args.no_wait: bundle_installation.wait_for_installation(response_json['bundleId'], args) log.info('Bundle loaded.') log.info('Start bundle with: conduct run{} {}'.format(args.cli_parameters, bundle_id)) log.info('Unload bundle with: conduct unload{} {}'.format(args.cli_parameters, bundle_id)) log.info('Print ConductR info with: conduct info{}'.format(args.cli_parameters)) if not log.is_info_enabled() and log.is_quiet_enabled(): log.quiet(response_json['bundleId']) return True
def run(args): """`conduct run` command""" log = logging.getLogger(__name__) if args.affinity is not None and args.api_version == '1': log.error( 'Affinity feature is only available for v1.1 onwards of ConductR') return elif args.affinity is not None: path = 'bundles/{}?scale={}&affinity={}'.format( args.bundle, args.scale, args.affinity) else: path = 'bundles/{}?scale={}'.format(args.bundle, args.scale) url = conduct_url.url(path, args) response = conduct_request.put(args.dcos_mode, conductr_host(args), url, auth=args.conductr_auth, verify=args.server_verification_file) validation.raise_for_status_inc_3xx(response) if log.is_verbose_enabled(): log.verbose(validation.pretty_json(response.text)) response_json = json.loads(response.text) bundle_id = response_json[ 'bundleId'] if args.long_ids else bundle_utils.short_id( response_json['bundleId']) log.info('Bundle run request sent.') if not args.no_wait: bundle_scale.wait_for_scale(response_json['bundleId'], args.scale, wait_for_is_active=True, args=args) if not args.disable_instructions: log.info('Stop bundle with: {} stop{} {}'.format( args.command, args.cli_parameters, bundle_id)) log.info('Print ConductR info with: {} info{}'.format( args.command, args.cli_parameters)) log.info('Print bundle info with: {} info{} {}'.format( args.command, args.cli_parameters, bundle_id)) return True
def post_license(args, license_file): """ Post license file to ConductR. :param args: input args obtained from argparse :param license_file: the path to license file """ url = conduct_url.url('license', args) response = conduct_request.post(args.dcos_mode, conductr_host(args), url, data=open(license_file, 'rb'), auth=args.conductr_auth, verify=args.server_verification_file) if response.status_code == 503: return False else: validation.raise_for_status_inc_3xx(response) return True
def acls(args): """`conduct acls` command""" log = logging.getLogger(__name__) url = conduct_url.url('bundles', args) response = conduct_request.get(args.dcos_mode, conductr_host(args), url, timeout=DEFAULT_HTTP_TIMEOUT) validation.raise_for_status_inc_3xx(response) if log.is_verbose_enabled(): log.verbose(validation.pretty_json(response.text)) def get_system_version(bundle): if 'systemVersion' in bundle['attributes']: return bundle['attributes']['systemVersion'] else: return bundle['attributes']['system'].split('-')[-1] def is_started(bundle_executions): for execution in bundle_executions: if execution['isStarted']: return 'Running' return 'Starting' all_acls = [ { 'acl': acl, 'system': bundle['attributes']['system'], 'system_version': get_system_version(bundle), 'endpoint_name': endpoint_name, 'bundle_id': bundle['bundleId'] if args.long_ids else bundle_utils.short_id(bundle['bundleId']), 'bundle_name': bundle['attributes']['bundleName'], 'status': is_started(bundle['bundleExecutions']) } for bundle in json.loads(response.text) if bundle['bundleExecutions'] for endpoint_name, endpoint in bundle['bundleConfig']['endpoints'].items() if 'acls' in endpoint for acl in endpoint['acls'] ] if args.protocol_family == 'http': http_acls = [acl for acl in all_acls if 'http' in acl['acl']] display_http_acls(log, http_acls) elif args.protocol_family == 'tcp': tcp_acls = [acl for acl in all_acls if 'tcp' in acl['acl']] display_tcp_acls(log, tcp_acls) return True
def acls(args): """`conduct acls` command""" log = logging.getLogger(__name__) url = conduct_url.url('bundles', args) # At the time when this comment is being written, we need to pass the Host header when making HTTP request due to # a bug with requests python library not working properly when IPv6 address is supplied: # https://github.com/kennethreitz/requests/issues/3002 # The workaround for this problem is to explicitly set the Host header when making HTTP request. # This fix is benign and backward compatible as the library would do this when making HTTP request anyway. response = requests.get(url, timeout=DEFAULT_HTTP_TIMEOUT, headers=conduct_url.request_headers(args)) validation.raise_for_status_inc_3xx(response) if log.is_verbose_enabled(): log.verbose(validation.pretty_json(response.text)) def get_system_version(bundle): if 'systemVersion' in bundle['attributes']: return bundle['attributes']['systemVersion'] else: return bundle['attributes']['system'].split('-')[-1] all_acls = [ { 'acl': acl, 'system': bundle['attributes']['system'], 'system_version': get_system_version(bundle), 'endpoint_name': endpoint_name, 'bundle_id': bundle['bundleId'] if args.long_ids else bundle_utils.short_id(bundle['bundleId']), 'bundle_name': bundle['attributes']['bundleName'], 'status': 'Running' if execution['isStarted'] else 'Starting' } for bundle in json.loads(response.text) for execution in bundle['bundleExecutions'] for endpoint_name, endpoint in bundle['bundleConfig']['endpoints'].items() if 'acls' in endpoint for acl in endpoint['acls'] ] if args.protocol_family == 'http': http_acls = [acl for acl in all_acls if 'http' in acl['acl']] display_http_acls(log, http_acls) elif args.protocol_family == 'tcp': tcp_acls = [acl for acl in all_acls if 'tcp' in acl['acl']] display_tcp_acls(log, tcp_acls) return True
def load_v1(args): log = logging.getLogger(__name__) log.info('Retrieving bundle...') custom_settings = args.custom_settings resolve_cache_dir = args.resolve_cache_dir bundle_name, bundle_file = resolver.resolve_bundle(custom_settings, resolve_cache_dir, args.bundle) configuration_name, configuration_file = (None, None) if args.configuration is not None: log.info('Retrieving configuration...') configuration_name, configuration_file = resolver.resolve_bundle(custom_settings, resolve_cache_dir, args.configuration) bundle_conf = ConfigFactory.parse_string(bundle_utils.conf(bundle_file)) overlay_bundle_conf = None if configuration_file is None else \ ConfigFactory.parse_string(bundle_utils.conf(configuration_file)) with_bundle_configurations = partial(apply_to_configurations, bundle_conf, overlay_bundle_conf) url = conduct_url.url('bundles', args) files = get_payload(bundle_name, bundle_file, with_bundle_configurations) if configuration_file is not None: files.append(('configuration', (configuration_name, open(configuration_file, 'rb')))) log.info('Loading bundle to ConductR...') response = requests.post(url, files=files, timeout=LOAD_HTTP_TIMEOUT) validation.raise_for_status_inc_3xx(response) if log.is_verbose_enabled(): log.verbose(validation.pretty_json(response.text)) response_json = json.loads(response.text) bundle_id = response_json['bundleId'] if args.long_ids else bundle_utils.short_id(response_json['bundleId']) if not args.no_wait: bundle_installation.wait_for_installation(response_json['bundleId'], args) log.info('Bundle loaded.') log.info('Start bundle with: conduct run{} {}'.format(args.cli_parameters, bundle_id)) log.info('Unload bundle with: conduct unload{} {}'.format(args.cli_parameters, bundle_id)) log.info('Print ConductR info with: conduct info{}'.format(args.cli_parameters)) if not log.is_info_enabled() and log.is_quiet_enabled(): log.quiet(response_json['bundleId']) return True
def service_names(args): """`conduct service-names` command""" log = logging.getLogger(__name__) url = conduct_url.url('bundles', args) response = conduct_request.get(args.dcos_mode, conductr_host(args), url, timeout=DEFAULT_HTTP_TIMEOUT) validation.raise_for_status_inc_3xx(response) if log.is_verbose_enabled(): log.verbose(validation.pretty_json(response.text)) bundles = json.loads(response.text) data, duplicate_endpoints = get_service_names_from_bundles(args, bundles) display_service_names(log, data, duplicate_endpoints) return True
def run(args): """`conduct run` command""" log = logging.getLogger(__name__) if args.affinity is not None and args.api_version == '1': log.error( 'Affinity feature is only available for v1.1 onwards of ConductR') return elif args.affinity is not None: path = 'bundles/{}?scale={}&affinity={}'.format( args.bundle, args.scale, args.affinity) else: path = 'bundles/{}?scale={}'.format(args.bundle, args.scale) url = conduct_url.url(path, args) # At the time when this comment is being written, we need to pass the Host header when making HTTP request due to # a bug with requests python library not working properly when IPv6 address is supplied: # https://github.com/kennethreitz/requests/issues/3002 # The workaround for this problem is to explicitly set the Host header when making HTTP request. # This fix is benign and backward compatible as the library would do this when making HTTP request anyway. response = requests.put(url, headers=conduct_url.request_headers(args)) validation.raise_for_status_inc_3xx(response) if log.is_verbose_enabled(): log.verbose(validation.pretty_json(response.text)) response_json = json.loads(response.text) bundle_id = response_json[ 'bundleId'] if args.long_ids else bundle_utils.short_id( response_json['bundleId']) log.info('Bundle run request sent.') if not args.no_wait: bundle_scale.wait_for_scale(response_json['bundleId'], args.scale, args) log.info('Stop bundle with: conduct stop{} {}'.format( args.cli_parameters, bundle_id)) log.info('Print ConductR info with: conduct info{}'.format( args.cli_parameters)) return True
def info(args): """`conduct info` command""" log = logging.getLogger(__name__) url = conduct_url.url('bundles', args) # At the time when this comment is being written, we need to pass the Host header when making HTTP request due to # a bug with requests python library not working properly when IPv6 address is supplied: # https://github.com/kennethreitz/requests/issues/3002 # The workaround for this problem is to explicitly set the Host header when making HTTP request. # This fix is benign and backward compatible as the library would do this when making HTTP request anyway. response = requests.get(url, timeout=DEFAULT_HTTP_TIMEOUT, headers=conduct_url.request_headers(args)) validation.raise_for_status_inc_3xx(response) if log.is_verbose_enabled(): log.verbose(validation.pretty_json(response.text)) data = [ { 'id': ('! ' if bundle.get('hasError', False) else '') + (bundle['bundleId'] if args.long_ids else bundle_utils.short_id(bundle['bundleId'])), 'name': bundle['attributes']['bundleName'], 'replications': len(bundle['bundleInstallations']), 'starting': sum([not execution['isStarted'] for execution in bundle['bundleExecutions']]), 'executions': sum([execution['isStarted'] for execution in bundle['bundleExecutions']]) } for bundle in json.loads(response.text) ] data.insert(0, {'id': 'ID', 'name': 'NAME', 'replications': '#REP', 'starting': '#STR', 'executions': '#RUN'}) padding = 2 column_widths = dict(screen_utils.calc_column_widths(data), **{'padding': ' ' * padding}) has_error = False for row in data: has_error |= '!' in row['id'] log.screen('''\ {id: <{id_width}}{padding}\ {name: <{name_width}}{padding}\ {replications: >{replications_width}}{padding}\ {starting: >{starting_width}}{padding}\ {executions: >{executions_width}}'''.format(**dict(row, **column_widths)).rstrip()) if has_error: log.screen('There are errors: use `conduct events` or `conduct logs` for further information') return True
def agents(args): """`conduct agents` command""" log = logging.getLogger(__name__) request_url = conduct_url.url('agents', args) response = conduct_request.get(args.dcos_mode, conductr_host(args), request_url, auth=args.conductr_auth, verify=args.server_verification_file, timeout=DEFAULT_HTTP_TIMEOUT) validation.raise_for_status_inc_3xx(response) if log.is_verbose_enabled(): log.verbose(validation.pretty_json(response.text)) raw_data = json.loads(response.text) data = [ { 'address': 'ADDRESS', 'roles': 'ROLES', 'observed': 'OBSERVED BY' } ] for entry in raw_data: if args.role is None or args.role in entry['roles']: data.append({ 'address': entry['address'], 'roles': ','.join(entry['roles']), 'observed': ','.join(map(lambda e: e['node']['address'], entry['observedBy'])) }) padding = 2 column_widths = dict(screen_utils.calc_column_widths(data), **{'padding': ' ' * padding}) for row in data: log.screen('''\ {address: <{address_width}}{padding}\ {roles: <{roles_width}}{padding}\ {observed: >{observed_width}}{padding}'''.format(**dict(row, **column_widths)).rstrip()) return True
def info(args): """`conduct info` command""" log = logging.getLogger(__name__) url = conduct_url.url('bundles', args) response = conduct_request.get(args.dcos_mode, conductr_host(args), url, auth=args.conductr_auth, verify=args.server_verification_file, timeout=DEFAULT_HTTP_TIMEOUT) validation.raise_for_status_inc_3xx(response) if log.is_verbose_enabled(): log.verbose(validation.pretty_json(response.text)) bundles = json.loads(response.text) if args.bundle: return conduct_info_inspect.display_bundle(args, bundles, args.bundle) else: return conduct_info_list.display_bundles(args, bundles)
def info(args): """`conduct info` command""" log = logging.getLogger(__name__) url = conduct_url.url('bundles', args) response = conduct_request.get(args.dcos_mode, conductr_host(args), url, auth=args.conductr_auth, verify=args.server_verification_file, timeout=DEFAULT_HTTP_TIMEOUT) validation.raise_for_status_inc_3xx(response) if log.is_verbose_enabled(): log.verbose(validation.pretty_json(response.text)) data = [ { 'id': ('! ' if bundle.get('hasError', False) else '') + (bundle['bundleId'] if args.long_ids else bundle_utils.short_id(bundle['bundleId'])), 'name': bundle['attributes']['bundleName'], 'replications': len(bundle['bundleInstallations']), 'starting': sum([not execution['isStarted'] for execution in bundle['bundleExecutions']]), 'executions': sum([execution['isStarted'] for execution in bundle['bundleExecutions']]) } for bundle in json.loads(response.text) ] data.insert(0, {'id': 'ID', 'name': 'NAME', 'replications': '#REP', 'starting': '#STR', 'executions': '#RUN'}) padding = 2 column_widths = dict(screen_utils.calc_column_widths(data), **{'padding': ' ' * padding}) has_error = False for row in data: has_error |= '!' in row['id'] log.screen('''\ {id: <{id_width}}{padding}\ {name: <{name_width}}{padding}\ {replications: >{replications_width}}{padding}\ {starting: >{starting_width}}{padding}\ {executions: >{executions_width}}'''.format(**dict(row, **column_widths)).rstrip()) if has_error: log.screen('There are errors: use `conduct events` or `conduct logs` for further information') return True
def download_license(args, save_to): """ Downloads license from Lightbend.com. :param args: input args obtained from argparse. :param save_to: the path where downloaded license will be saved to. :return: path to the license file. """ log = logging.getLogger(__name__) cached_token = license_auth.get_cached_auth_token() if cached_token: auth_token = cached_token else: auth_token = license_auth.prompt_for_auth_token() license_download_host = urlparse(args.license_download_url).hostname auth_token_b64_bytes = base64.b64encode(bytes(auth_token, 'UTF-8')) auth_token_b64 = auth_token_b64_bytes.decode('UTF-8') auth_header = {'Authorization': 'Bearer {}'.format(auth_token_b64)} response = conduct_request.get(args.dcos_mode, license_download_host, args.license_download_url, headers=auth_header, verify=args.server_verification_file) if log.is_verbose_enabled(): log.verbose(response.text) if response.status_code == 401 or response.status_code == 303: license_auth.remove_cached_auth_token() raise LicenseDownloadError([response.text]) elif response.status_code == 403: raise LicenseDownloadError([response.text]) validation.raise_for_status_inc_3xx(response) license_auth.save_auth_token(auth_token) save_license_data(response.text, save_to)
def get_license(args): """ Get license from ConductR. Returns a tuple of Boolean, get_license_payload. The following return values are allowed - False, None: License endpoint does not exist at the ConductR control protocol - True, None: No license has been uploaded to ConductR - True, license_data: Returns the current license from ConductR :param args: input args obtained from argparse """ url = conduct_url.url('license', args) try: response = conduct_request.get(args.dcos_mode, conductr_host(args), url, auth=args.conductr_auth) if response.status_code == 404 or response.status_code == 503: return False, None else: validation.raise_for_status_inc_3xx(response) return True, json.loads(response.text) except DCOSHTTPException as e: if e.response.status_code == 404 or e.response.status_code == 503: return False, None else: raise e
def run(args): """`conduct run` command""" log = logging.getLogger(__name__) if args.affinity is not None and args.api_version == '1': log.error('Affinity feature is only available for v1.1 onwards of ConductR') return elif args.affinity is not None: path = 'bundles/{}?scale={}&affinity={}'.format(args.bundle, args.scale, args.affinity) else: path = 'bundles/{}?scale={}'.format(args.bundle, args.scale) url = conduct_url.url(path, args) # At the time when this comment is being written, we need to pass the Host header when making HTTP request due to # a bug with requests python library not working properly when IPv6 address is supplied: # https://github.com/kennethreitz/requests/issues/3002 # The workaround for this problem is to explicitly set the Host header when making HTTP request. # This fix is benign and backward compatible as the library would do this when making HTTP request anyway. response = requests.put(url, headers=conduct_url.request_headers(args)) validation.raise_for_status_inc_3xx(response) if log.is_verbose_enabled(): log.verbose(validation.pretty_json(response.text)) response_json = json.loads(response.text) bundle_id = response_json['bundleId'] if args.long_ids else bundle_utils.short_id(response_json['bundleId']) log.info('Bundle run request sent.') if not args.no_wait: bundle_scale.wait_for_scale(response_json['bundleId'], args.scale, args) log.info('Stop bundle with: conduct stop{} {}'.format(args.cli_parameters, bundle_id)) log.info('Print ConductR info with: conduct info{}'.format(args.cli_parameters)) return True
def acls(args): """`conduct acls` command""" log = logging.getLogger(__name__) url = conduct_url.url('bundles', args) response = conduct_request.get(args.dcos_mode, conductr_host(args), url, timeout=DEFAULT_HTTP_TIMEOUT) validation.raise_for_status_inc_3xx(response) if log.is_verbose_enabled(): log.verbose(validation.pretty_json(response.text)) bundles = json.loads(response.text) all_acls, http_acls, tcp_acls = get_acls_from_bundles(args, bundles) if args.protocol_family == 'http': display_http_acls(log, http_acls) elif args.protocol_family == 'tcp': display_tcp_acls(log, tcp_acls) return True
def stop(args): """`conduct stop` command""" log = logging.getLogger(__name__) path = 'bundles/{}?scale=0'.format(args.bundle) url = conduct_url.url(path, args) response = requests.put(url, timeout=DEFAULT_HTTP_TIMEOUT) validation.raise_for_status_inc_3xx(response) if log.is_verbose_enabled(): log.verbose(validation.pretty_json(response.text)) response_json = json.loads(response.text) bundle_id = response_json['bundleId'] if args.long_ids else bundle_utils.short_id(response_json['bundleId']) log.info('Bundle stop request sent.') if not args.no_wait: bundle_scale.wait_for_scale(response_json['bundleId'], 0, args) log.info('Unload bundle with: conduct unload{} {}'.format(args.cli_parameters, bundle_id)) log.info('Print ConductR info with: conduct info{}'.format(args.cli_parameters)) return True
def info(args): """`conduct info` command""" log = logging.getLogger(__name__) url = conduct_url.url('bundles', args) # At the time when this comment is being written, we need to pass the Host header when making HTTP request due to # a bug with requests python library not working properly when IPv6 address is supplied: # https://github.com/kennethreitz/requests/issues/3002 # The workaround for this problem is to explicitly set the Host header when making HTTP request. # This fix is benign and backward compatible as the library would do this when making HTTP request anyway. response = requests.get(url, timeout=DEFAULT_HTTP_TIMEOUT, headers=conduct_url.request_headers(args)) validation.raise_for_status_inc_3xx(response) if log.is_verbose_enabled(): log.verbose(validation.pretty_json(response.text)) data = [{ 'id': ('! ' if bundle.get('hasError', False) else '') + (bundle['bundleId'] if args.long_ids else bundle_utils.short_id(bundle['bundleId'])), 'name': bundle['attributes']['bundleName'], 'replications': len(bundle['bundleInstallations']), 'starting': sum([ not execution['isStarted'] for execution in bundle['bundleExecutions'] ]), 'executions': sum([ execution['isStarted'] for execution in bundle['bundleExecutions'] ]) } for bundle in json.loads(response.text)] data.insert( 0, { 'id': 'ID', 'name': 'NAME', 'replications': '#REP', 'starting': '#STR', 'executions': '#RUN' }) padding = 2 column_widths = dict(screen_utils.calc_column_widths(data), **{'padding': ' ' * padding}) has_error = False for row in data: has_error |= '!' in row['id'] log.screen('''\ {id: <{id_width}}{padding}\ {name: <{name_width}}{padding}\ {replications: >{replications_width}}{padding}\ {starting: >{starting_width}}{padding}\ {executions: >{executions_width}}'''.format( **dict(row, **column_widths)).rstrip()) if has_error: log.screen( 'There are errors: use `conduct events` or `conduct logs` for further information' ) return True
def deploy(args): """`conduct deploy` command""" log = logging.getLogger(__name__) bintray_webhook_secret = custom_settings.load_bintray_webhook_secret(args) if not bintray_webhook_secret: log.error( 'The deploy command requires bintray webhook secret to be configured' ) log.error('Add the following configuration to the ' 'custom settings file {}'.format( vars(args).get('custom_settings_file'))) log.error( ' conductr.continuous-delivery.bintray-webhook-secret = "configured-continuous-delivery-secret"' ) return resolved_version = resolver.resolve_bundle_version(args.custom_settings, args.bundle) if not resolved_version: log.error('Unable to resolve bundle {}'.format(args.bundle)) return # Build Continuous Delivery URL using our resolver mechanism deploy_uri = resolver.continuous_delivery_uri(args.custom_settings, resolved_version) if not deploy_uri: log.error('Unable to form Continuous Delivery uri for {}'.format( args.bundle)) return # Confirm with the user unless auto deploy is enabled accepted = True if args.auto_deploy else request_deploy_confirmation( resolved_version, args) if not accepted: log.info('Abort') return url = conduct_url.url(deploy_uri, args) # JSON Payload for deployment request payload = { 'package': resolved_version['package_name'], 'version': '{}-{}'.format(resolved_version['compatibility_version'], resolved_version['digest']) } # HTTP headers required for deployment request hmac_digest = bundle_deploy.generate_hmac_signature( bintray_webhook_secret, resolved_version['package_name']) headers = {'X-Bintray-WebHook-Hmac': hmac_digest} response = conduct_request.post(args.dcos_mode, conductr_host(args), url, json=payload, headers=headers, auth=args.conductr_auth, verify=args.server_verification_file) validation.raise_for_status_inc_3xx(response) deployment_id = response.text log.info('Deployment request sent.') log.info('Deployment id {}'.format(deployment_id)) if not args.no_wait: bundle_deploy.wait_for_deployment_complete(deployment_id, resolved_version, args) return True
def members(args): """`conduct members` command""" log = logging.getLogger(__name__) request_url = conduct_url.url('members', args) response = conduct_request.get(args.dcos_mode, conductr_host(args), request_url, auth=args.conductr_auth, verify=args.server_verification_file, timeout=DEFAULT_HTTP_TIMEOUT) validation.raise_for_status_inc_3xx(response) if log.is_verbose_enabled(): log.verbose(validation.pretty_json(response.text)) raw_data = json.loads(response.text) data = [{ 'address': 'ADDRESS', 'uid': 'UID', 'roles': 'ROLES', 'status': 'STATUS', 'reachable': 'REACHABLE' }] unreachable_nodes = [] for entry in raw_data['unreachable']: unreachable_nodes.append(entry['node']) for entry in raw_data['members']: if args.role is None or args.role in entry['roles']: data.append({ 'address': entry['node']['address'], 'uid': entry['node']['uid'], 'roles': ','.join(entry['roles']), 'status': entry['status'], 'reachable': 'Yes' if entry['node'] not in unreachable_nodes else 'No' }) padding = 2 column_widths = dict(screen_utils.calc_column_widths(data), **{'padding': ' ' * padding}) for row in data: log.screen('''\ {uid: <{uid_width}}{padding}\ {address: <{address_width}}{padding}\ {roles: <{roles_width}}{padding}\ {status: <{status_width}}{padding}\ {reachable: >{reachable_width}}'''.format( **dict(row, **column_widths)).rstrip()) return True
def load_v1(args): log = logging.getLogger(__name__) log.info('Retrieving bundle...') custom_settings = args.custom_settings resolve_cache_dir = args.resolve_cache_dir bundle_name, bundle_file = resolver.resolve_bundle(custom_settings, resolve_cache_dir, args.bundle) configuration_name, configuration_file = (None, None) if args.configuration is not None: log.info('Retrieving configuration...') configuration_name, configuration_file = resolver.resolve_bundle( custom_settings, resolve_cache_dir, args.configuration) bundle_conf = ConfigFactory.parse_string(bundle_utils.conf(bundle_file)) overlay_bundle_conf = None if configuration_file is None else \ ConfigFactory.parse_string(bundle_utils.conf(configuration_file)) with_bundle_configurations = partial(apply_to_configurations, bundle_conf, overlay_bundle_conf) url = conduct_url.url('bundles', args) files = get_payload(bundle_name, bundle_file, with_bundle_configurations) if configuration_file is not None: files.append(('configuration', (configuration_name, open(configuration_file, 'rb')))) log.info('Loading bundle to ConductR...') # At the time when this comment is being written, we need to pass the Host header when making HTTP request due to # a bug with requests python library not working properly when IPv6 address is supplied: # https://github.com/kennethreitz/requests/issues/3002 # The workaround for this problem is to explicitly set the Host header when making HTTP request. # This fix is benign and backward compatible as the library would do this when making HTTP request anyway. response = requests.post(url, files=files, timeout=LOAD_HTTP_TIMEOUT, headers=conduct_url.request_headers(args)) validation.raise_for_status_inc_3xx(response) if log.is_verbose_enabled(): log.verbose(validation.pretty_json(response.text)) response_json = json.loads(response.text) bundle_id = response_json[ 'bundleId'] if args.long_ids else bundle_utils.short_id( response_json['bundleId']) if not args.no_wait: bundle_installation.wait_for_installation(response_json['bundleId'], args) log.info('Bundle loaded.') log.info('Start bundle with: conduct run{} {}'.format( args.cli_parameters, bundle_id)) log.info('Unload bundle with: conduct unload{} {}'.format( args.cli_parameters, bundle_id)) log.info('Print ConductR info with: conduct info{}'.format( args.cli_parameters)) if not log.is_info_enabled() and log.is_quiet_enabled(): log.quiet(response_json['bundleId']) return True
def deploy(args): """`conduct deploy` command""" log = logging.getLogger(__name__) bintray_webhook_secret = custom_settings.load_bintray_webhook_secret(args) if not bintray_webhook_secret: log.error('The deploy command requires bintray webhook secret to be configured') log.error('Add the following configuration to the ' 'custom settings file {}'.format(vars(args).get('custom_settings_file'))) log.error(' conductr.continuous-delivery.bintray-webhook-secret = "configured-continuous-delivery-secret"') return resolved_version = resolver.resolve_bundle_version(args.custom_settings, args.bundle) if not resolved_version: log.error('Unable to resolve bundle {}'.format(args.bundle)) return # Build Continuous Delivery URL using our resolver mechanism deploy_uri = resolver.continuous_delivery_uri(args.custom_settings, resolved_version) if not deploy_uri: log.error('Unable to form Continuous Delivery uri for {}'.format(args.bundle)) return # Confirm with the user unless auto deploy is enabled accepted = True if args.auto_deploy else request_deploy_confirmation(resolved_version, args) if not accepted: log.info('Abort') return url = conduct_url.url(deploy_uri, args) # JSON Payload for deployment request payload = { 'package': resolved_version['package_name'], 'version': '{}-{}'.format(resolved_version['compatibility_version'], resolved_version['digest']) } # HTTP headers required for deployment request hmac_digest = bundle_deploy.generate_hmac_signature(bintray_webhook_secret, resolved_version['package_name']) headers = { 'X-Bintray-WebHook-Hmac': hmac_digest } response = conduct_request.post(args.dcos_mode, conductr_host(args), url, json=payload, headers=headers, auth=args.conductr_auth, verify=args.server_verification_file) validation.raise_for_status_inc_3xx(response) deployment_id = response.text log.info('Deployment request sent.') log.info('Deployment id {}'.format(deployment_id)) if not args.no_wait: bundle_deploy.wait_for_deployment_complete(deployment_id, resolved_version, args) return True
def services(args): """`conduct services` command""" log = logging.getLogger(__name__) url = conduct_url.url('bundles', args) # At the time when this comment is being written, we need to pass the Host header when making HTTP request due to # a bug with requests python library not working properly when IPv6 address is supplied: # https://github.com/kennethreitz/requests/issues/3002 # The workaround for this problem is to explicitly set the Host header when making HTTP request. # This fix is benign and backward compatible as the library would do this when making HTTP request anyway. response = requests.get(url, timeout=DEFAULT_HTTP_TIMEOUT, headers=conduct_url.request_headers(args)) validation.raise_for_status_inc_3xx(response) if log.is_verbose_enabled(): log.verbose(validation.pretty_json(response.text)) data = sorted([({ 'service': service, 'bundle_id': bundle['bundleId'] if args.long_ids else bundle_utils.short_id(bundle['bundleId']), 'bundle_name': bundle['attributes']['bundleName'], 'status': 'Running' if execution['isStarted'] else 'Starting' }) for bundle in json.loads(response.text) for execution in bundle['bundleExecutions'] for endpoint_name, endpoint in bundle['bundleConfig'] ['endpoints'].items() if 'services' in endpoint for service in endpoint['services']], key=lambda line: line['service']) service_endpoints = {} for service in data: url = urlparse(service['service']) if not (url.path == '' or url.path == '/'): try: service_endpoints[url.path] |= {service['service']} except KeyError: service_endpoints[url.path] = {service['service']} duplicate_endpoints = [service for (service, endpoint) in service_endpoints.items() if len(endpoint) > 1] \ if len(service_endpoints) > 0 else [] data.insert( 0, { 'service': 'SERVICE', 'bundle_id': 'BUNDLE ID', 'bundle_name': 'BUNDLE NAME', 'status': 'STATUS' }) padding = 2 column_widths = dict(screen_utils.calc_column_widths(data), **{'padding': ' ' * padding}) for row in data: log.screen('{service: <{service_width}}{padding}' '{bundle_id: <{bundle_id_width}}{padding}' '{bundle_name: <{bundle_name_width}}{padding}' '{status: <{status_width}}'.format( **dict(row, **column_widths)).rstrip()) if len(duplicate_endpoints) > 0: log.screen('') log.warning( 'Multiple endpoints found for the following services: {}'.format( ', '.join(duplicate_endpoints))) log.warning('Service resolution for these services is undefined.') return True
def service_names(args): """`conduct service-names` command""" log = logging.getLogger(__name__) url = conduct_url.url('bundles', args) response = conduct_request.get(args.dcos_mode, conductr_host(args), url, timeout=DEFAULT_HTTP_TIMEOUT) validation.raise_for_status_inc_3xx(response) if log.is_verbose_enabled(): log.verbose(validation.pretty_json(response.text)) def execution_status(bundle_executions): for execution in bundle_executions: if execution['isStarted']: return 'Running' return 'Starting' def get_service_name_from_service_uri(service_uri): paths = urlparse(service_uri).path.split('/') if len(paths) > 1: return paths[1] else: return '' data_from_service_uri = [ ( { 'service_name': get_service_name_from_service_uri(service_uri), 'service_uri': service_uri, 'bundle_id': bundle['bundleId'] if args.long_ids else bundle_utils.short_id( bundle['bundleId']), 'bundle_name': bundle['attributes']['bundleName'], 'status': execution_status(bundle['bundleExecutions']) } ) for bundle in json.loads(response.text) if bundle['bundleExecutions'] for endpoint_name, endpoint in bundle['bundleConfig']['endpoints'].items() if 'services' in endpoint for service_uri in endpoint['services'] ] data_from_service_name = [ ( { 'service_name': endpoint['serviceName'], 'service_uri': None, 'bundle_id': bundle['bundleId'] if args.long_ids else bundle_utils.short_id( bundle['bundleId']), 'bundle_name': bundle['attributes']['bundleName'], 'status': execution_status(bundle['bundleExecutions']) } ) for bundle in json.loads(response.text) if bundle['bundleExecutions'] for endpoint_name, endpoint in bundle['bundleConfig']['endpoints'].items() if 'serviceName' in endpoint ] data = data_from_service_uri + data_from_service_name data = sorted([entry for entry in data if entry['service_name']], key=lambda line: line['service_name']) service_endpoints = {} for service in data: url = urlparse(service['service_uri']) if not (url.path == '' or url.path == '/'): try: service_endpoints[url.path] |= {service['service_uri']} except KeyError: service_endpoints[url.path] = {service['service_uri']} duplicate_endpoints = [service for (service, endpoint) in service_endpoints.items() if len(endpoint) > 1] \ if len(service_endpoints) > 0 else [] data.insert(0, {'service_name': 'SERVICE NAME', 'bundle_id': 'BUNDLE ID', 'bundle_name': 'BUNDLE NAME', 'status': 'STATUS'}) padding = 2 column_widths = dict(screen_utils.calc_column_widths(data), **{'padding': ' ' * padding}) for row in data: log.screen( '{service_name: <{service_name_width}}{padding}' '{bundle_id: <{bundle_id_width}}{padding}' '{bundle_name: <{bundle_name_width}}{padding}' '{status: <{status_width}}'.format(**dict(row, **column_widths)).rstrip()) if len(duplicate_endpoints) > 0: log.screen('') log.warning('Multiple endpoints found for the following services: {}'.format(', '.join(duplicate_endpoints))) log.warning('Service resolution for these services is undefined.') return True
def load_v1(args): log = logging.getLogger(__name__) log.info('Retrieving bundle..') custom_settings = args.custom_settings resolve_cache_dir = args.resolve_cache_dir validate_cache_dir_permissions(resolve_cache_dir, log) bundle_file_name, bundle_file = resolver.resolve_bundle(custom_settings, resolve_cache_dir, args.bundle) configuration_file_name, configuration_file = (None, None) if args.configuration is not None: log.info('Retrieving configuration..') configuration_file_name, configuration_file = resolver.resolve_bundle_configuration(custom_settings, resolve_cache_dir, args.configuration) bundle_conf = ConfigFactory.parse_string(bundle_utils.conf(bundle_file)) overlay_bundle_conf = None if configuration_file is None else \ ConfigFactory.parse_string(bundle_utils.conf(configuration_file)) with_bundle_configurations = partial(apply_to_configurations, bundle_conf, overlay_bundle_conf) url = conduct_url.url('bundles', args) files = get_payload(bundle_file_name, bundle_file, with_bundle_configurations) if configuration_file is not None: files.append(('configuration', (configuration_file_name, open(configuration_file, 'rb')))) # TODO: Delete the bundle configuration file. # Currently, this results into a permission error on Windows. # Therefore, the deletion is disabled for now. # Issue: https://github.com/typesafehub/conductr-cli/issues/175 # if configuration_file and os.path.exists(configuration_file): # os.remove(configuration_file) log.info('Loading bundle to ConductR..') multipart = create_multipart(log, files) response = conduct_request.post(args.dcos_mode, conductr_host(args), url, data=multipart, auth=args.conductr_auth, verify=args.server_verification_file, headers={'Content-Type': multipart.content_type}) validation.raise_for_status_inc_3xx(response) if log.is_verbose_enabled(): log.verbose(validation.pretty_json(response.text)) response_json = json.loads(response.text) bundle_id = response_json['bundleId'] if args.long_ids else bundle_utils.short_id(response_json['bundleId']) if not args.no_wait: bundle_installation.wait_for_installation(response_json['bundleId'], args) cleanup_old_bundles(resolve_cache_dir, bundle_file_name, excluded=bundle_file) log.info('Bundle loaded.') if not args.disable_instructions: log.info('Start bundle with: {} run{} {}'.format(args.command, args.cli_parameters, bundle_id)) log.info('Unload bundle with: {} unload{} {}'.format(args.command, args.cli_parameters, bundle_id)) log.info('Print ConductR info with: {} info{}'.format(args.command, args.cli_parameters)) if not log.is_info_enabled() and log.is_quiet_enabled(): log.quiet(response_json['bundleId']) return True
def load_v1(args): log = logging.getLogger(__name__) log.info('Retrieving bundle..') custom_settings = args.custom_settings bundle_resolve_cache_dir = args.bundle_resolve_cache_dir configuration_cache_dir = args.configuration_resolve_cache_dir validate_cache_dir_permissions(bundle_resolve_cache_dir, configuration_cache_dir, log) initial_bundle_file_name, bundle_file = resolver.resolve_bundle( custom_settings, bundle_resolve_cache_dir, args.bundle, args.offline_mode) configuration_file_name, configuration_file = (None, None) if args.configuration is not None: log.info('Retrieving configuration..') configuration_file_name, configuration_file = \ resolver.resolve_bundle_configuration(custom_settings, configuration_cache_dir, args.configuration, args.offline_mode) bundle_conf_text = bundle_utils.conf(bundle_file) bundle_conf = ConfigFactory.parse_string(bundle_conf_text) bundle_file_name, bundle_open_file = open_bundle(initial_bundle_file_name, bundle_file, bundle_conf_text) overlay_bundle_conf = None if configuration_file is None else \ ConfigFactory.parse_string(bundle_utils.conf(configuration_file)) with_bundle_configurations = partial(apply_to_configurations, bundle_conf, overlay_bundle_conf) url = conduct_url.url('bundles', args) files = get_payload(bundle_file_name, bundle_open_file, with_bundle_configurations) if configuration_file is not None: open_configuration_file, config_digest = bundle_utils.digest_extract_and_open( configuration_file) files.append(('configuration', (configuration_file_name, open_configuration_file))) # TODO: Delete the bundle configuration file. # Currently, this results into a permission error on Windows. # Therefore, the deletion is disabled for now. # Issue: https://github.com/typesafehub/conductr-cli/issues/175 # if configuration_file and os.path.exists(configuration_file): # os.remove(configuration_file) log.info('Loading bundle to ConductR..') multipart = create_multipart(log, files) response = conduct_request.post( args.dcos_mode, conductr_host(args), url, data=multipart, auth=args.conductr_auth, verify=args.server_verification_file, headers={'Content-Type': multipart.content_type}) validation.raise_for_status_inc_3xx(response) if log.is_verbose_enabled(): log.verbose(validation.pretty_json(response.text)) response_json = json.loads(response.text) bundle_id = response_json[ 'bundleId'] if args.long_ids else bundle_utils.short_id( response_json['bundleId']) if not args.no_wait: bundle_installation.wait_for_installation(response_json['bundleId'], args) cleanup_old_bundles(bundle_resolve_cache_dir, bundle_file_name, excluded=bundle_file) log.info('Bundle loaded.') if not args.disable_instructions: log.info('Start bundle with: {} run{} {}'.format( args.command, args.cli_parameters, bundle_id)) log.info('Unload bundle with: {} unload{} {}'.format( args.command, args.cli_parameters, bundle_id)) log.info('Print ConductR info with: {} info{}'.format( args.command, args.cli_parameters)) log.info('Print bundle info with: {} info{} {}'.format( args.command, args.cli_parameters, bundle_id)) if not log.is_info_enabled() and log.is_quiet_enabled(): log.quiet(response_json['bundleId']) return True