def main(): parser = argparse.ArgumentParser() parser.add_argument("--deploy-namespace", type=lambda x: (str(x).lower() == 'true'), default=True) deploy_options = deployment_options.load_deployment_options(parser) utils.verify_build_directory(deploy_options.namespace) if deploy_options.deploy_namespace is False: print("Not deploying namespace") return src_file = os.path.join(os.getcwd(), 'deploy/namespace/namespace.yaml') dst_file = os.path.join(os.getcwd(), 'build', deploy_options.namespace, 'namespace.yaml') with open(src_file, "r") as src: with open(dst_file, "w+") as dst: data = src.read() data = data.replace('REPLACE_NAMESPACE', f'"{deploy_options.namespace}"') print("Deploying {}".format(dst_file)) dst.write(data) utils.apply(target=deploy_options.target, namespace=deploy_options.namespace, profile=deploy_options.profile, file=dst_file)
def deploy_controller(deploy_options): src_file = os.path.join( os.getcwd(), 'deploy/assisted-installer-controller-ocp/assisted-controller-deployment.yaml' ) dst_file = os.path.join(os.getcwd(), 'build', deploy_options.namespace, 'assisted-controller-deployment.yaml') with open(src_file, "r") as src: with open(dst_file, "w+") as dst: data = src.read() data = data.replace('REPLACE_CONTROLLER_OCP_IMAGE', f'"{deploy_options.controller_image}"') data = data.replace('REPLACE_INVENTORY_URL', f'"{deploy_options.inventory_url}"') data = data.replace('REPLACE_CLUSTER_ID', f'"{deploy_options.cluster_id}"') data = data.replace('REPLACE_NAMESPACE', f'"{deploy_options.namespace}"') print("Deploying {}".format(dst_file)) dst.write(data) log.info('Deploying %s', dst_file) utils.apply(target=deploy_options.target, namespace=deploy_options.namespace, profile=deploy_options.profile, file=dst_file)
def main(): utils.verify_build_directory(deploy_options.namespace) with open(SRC_FILE, "r") as src: log.info( f"Loading source template file for assisted-image-service: {SRC_FILE}" ) raw_data = src.read() raw_data = raw_data.replace('REPLACE_NAMESPACE', f'"{deploy_options.namespace}"') raw_data = raw_data.replace('REPLACE_IMAGE_SERVICE_IMAGE', os.environ.get("IMAGE_SERVICE")) data = yaml.safe_load(raw_data) log.info(data) with open(DST_FILE, "w+") as dst: yaml.dump(data, dst, default_flow_style=False) if not deploy_options.apply_manifest: return log.info(f"Deploying {DST_FILE}") utils.apply(target=deploy_options.target, namespace=deploy_options.namespace, file=DST_FILE)
def main(): deploy_options = deployment_options.load_deployment_options() utils.verify_build_directory(deploy_options.namespace) if deploy_options.target == 'ocp': src_file = os.path.join(os.getcwd(), 'deploy/roles/ocp_role.yaml') dst_file = os.path.join(os.getcwd(), 'build', deploy_options.namespace, 'ocp_role.yaml') else: src_file = os.path.join(os.getcwd(), 'deploy/roles/default_role.yaml') dst_file = os.path.join(os.getcwd(), 'build', deploy_options.namespace, 'default_role.yaml') with open(src_file, "r") as src: with open(dst_file, "w+") as dst: data = src.read() data = data.replace('REPLACE_NAMESPACE', f'"{deploy_options.namespace}"') print("Deploying {}".format(dst_file)) dst.write(data) utils.apply(target=deploy_options.target, namespace=deploy_options.namespace, profile=deploy_options.profile, file=dst_file)
def main(): utils.verify_build_directory(deploy_options.namespace) ocm_secret = deploy_options.secret if ocm_secret == "": ocm_secret = '""' ocm_id = deploy_options.id if ocm_id == "": ocm_id = '""' src_file = os.path.join(os.getcwd(), 'deploy/assisted-installer-sso.yaml') dst_file = os.path.join(os.getcwd(), 'build', deploy_options.namespace, 'assisted-installer-sso.yaml') with open(src_file, "r") as src: with open(dst_file, "w+") as dst: data = src.read() data = data.replace('REPLACE_NAMESPACE', f'"{deploy_options.namespace}"') data = data.replace('REPLACE_OCM_SECRET', ocm_secret) data = data.replace('REPLACE_OCM_ID', ocm_id) print("Deploying {}".format(dst_file)) dst.write(data) utils.apply(target=deploy_options.target, namespace=deploy_options.namespace, profile=deploy_options.profile, file=dst_file)
def main(): utils.verify_build_directory(deploy_options.namespace) ## Main OLM Manifest for K8s if deploy_options.target != "oc-ingress": # K8s deployed = utils.check_if_exists(k8s_object='namespace', k8s_object_name='olm', target=deploy_options.target, namespace='olm', profile=deploy_options.profile) if not deployed: olm_manifests = [ "https://github.com/operator-framework/operator-lifecycle-manager/releases/download/0.15.1/crds.yaml", "https://github.com/operator-framework/operator-lifecycle-manager/releases/download/0.15.1/olm.yaml" ] for manifest_url in olm_manifests: dst_file = os.path.join( os.getcwd(), 'build', deploy_options.namespace, os.path.basename(urlparse(manifest_url).path)) print("Deploying {}".format(dst_file)) urlretrieve(manifest_url, dst_file) utils.apply(target=deploy_options.target, namespace=None, profile=deploy_options.profile, file=dst_file) check_deployment() else: # OCP print("OLM Deployment not necessary")
def deploy_prometheus_route(): '''Deploy Prometheus Route''' topic = 'Prometheus Operator Route' src_file = os.path.join(os.getcwd(),\ "deploy/monitoring/prometheus/assisted-installer-ocp-prometheus-route.yaml") dst_file = os.path.join(os.getcwd(),\ "build/assisted-installer-ocp-prometheus-route.yaml") try: # I have permissions ingress_domain = utils.get_domain() except: # I have not permissions, yes it's ugly... # This ingress should be there because of UI deployment json_path_ingress = '{.spec.rules[0].host}' cmd = "{} -n {} get ingress assisted-installer -o jsonpath='{}'".format( CMD_BIN, deploy_options.namespace, json_path_ingress) assisted_installer_ingress_domain = utils.check_output(cmd) if assisted_installer_ingress_domain.split( ".")[0] != 'assisted-installer': print("Error recovering the ingress route") sys.exit(1) ingress_domain = assisted_installer_ingress_domain.split(".", maxsplit=1)[1] with open(src_file, "r") as src: with open(dst_file, "w+") as dst: data = src.read() data = data.replace('REPLACE_NAMESPACE', deploy_options.namespace) data = data.replace("INGRESS_DOMAIN", ingress_domain) print("Deploying {}: {}".format(topic, dst_file)) dst.write(data) utils.apply(dst_file)
def deploy_postgres_storage(deploy_options): docs = utils.load_yaml_file_docs('deploy/postgres/postgres-storage.yaml') utils.set_namespace_in_yaml_docs(docs, deploy_options.namespace) log.info('Updating pvc size for postgres-pv-claim') pvc_size_utils.update_size_in_yaml_docs( target=deploy_options.target, ns=deploy_options.namespace, profile=deploy_options.profile, name='postgres-pv-claim', docs=docs ) dst_file = utils.dump_yaml_file_docs( basename=f'build/{deploy_options.namespace}/postgres-storage.yaml', docs=docs ) if not deploy_options.apply_manifest: return log.info('Deploying %s', dst_file) utils.apply( target=deploy_options.target, namespace=deploy_options.namespace, profile=deploy_options.profile, file=dst_file )
def main(): parser = argparse.ArgumentParser() parser.add_argument("--target") parser.add_argument("--domain") parser.add_argument("--subsystem-test", help='deploy in subsystem mode', action='store_true') deploy_options = deployment_options.load_deployment_options(parser) dst_file = os.path.join(os.getcwd(), "build/deploy_ui.yaml") image_fqdn = deployment_options.get_image_override(deploy_options, "ocp-metal-ui", "UI_IMAGE") runtime_cmd = utils.get_runtime_command() utils.check_output(f'{runtime_cmd} pull {image_fqdn}') cmd = f'{runtime_cmd} run {image_fqdn} /deploy/deploy_config.sh -i {image_fqdn} -n {deploy_options.namespace}' cmd += ' > {}'.format(dst_file) utils.check_output(cmd) print("Deploying {}".format(dst_file)) utils.apply(dst_file) # in case of openshift deploy ingress as well if deploy_options.target == "oc-ingress": src_file = os.path.join(os.getcwd(), "deploy/ui/ui_ingress.yaml") dst_file = os.path.join(os.getcwd(), "build/ui_ingress.yaml") with open(src_file, "r") as src: with open(dst_file, "w+") as dst: data = src.read() data = data.replace('REPLACE_NAMESPACE', deploy_options.namespace) data = data.replace("REPLACE_HOSTNAME", utils.get_service_host("assisted-installer-ui", deploy_options.target, deploy_options.domain, deploy_options.namespace)) print("Deploying {}".format(dst_file)) dst.write(data) utils.apply(dst_file)
def deploy_scality_storage(deploy_options): docs = utils.load_yaml_file_docs('deploy/s3/scality-storage.yaml') utils.set_namespace_in_yaml_docs(docs, deploy_options.namespace) log.info('Updating pvc size for scality-pv-claim') pvc_size_utils.update_size_in_yaml_docs( target=deploy_options.target, ns=deploy_options.namespace, profile=deploy_options.profile, name='scality-pv-claim', docs=docs ) dst_file = utils.dump_yaml_file_docs( basename=f'build/{deploy_options.namespace}/scality-storage.yaml', docs=docs ) log.info('Deploying %s', dst_file) utils.apply( target=deploy_options.target, namespace=deploy_options.namespace, profile=deploy_options.profile, file=dst_file )
def deploy_prometheus_sub(olm_ns, cat_src): '''Deploy Operator Subscription''' topic = 'Prometheus Operator Subscription' src_file = os.path.join(os.getcwd(),\ 'deploy/monitoring/prometheus/assisted-installer-operator-subscription.yaml') dst_file = os.path.join(os.getcwd(),\ 'build', deploy_options.namespace, 'assisted-installer-operator-subscription.yaml') with open(src_file, "r") as src: with open(dst_file, "w+") as dst: data = src.read() data = data.replace('REPLACE_NAMESPACE', f'"{deploy_options.namespace}"') data = data.replace("CAT_SRC", cat_src).replace("OLM_NAMESPACE", olm_ns) print("Deploying {}: {}".format(topic, dst_file)) dst.write(data) utils.apply( target=deploy_options.target, namespace=deploy_options.namespace, file=dst_file ) utils.wait_for_rollout( k8s_object='deployment', k8s_object_name='prometheus-operator', target=deploy_options.target, namespace=deploy_options.namespace )
def main(): deploy_options = handle_arguments() # TODO: delete once rename everything to assisted-installer if deploy_options.target == "oc-ingress": service_host = "assisted-installer.{}".format( utils.get_domain(deploy_options.domain)) service_port = "80" else: service_host = utils.get_service_host( SERVICE, deploy_options.target, namespace=deploy_options.namespace) service_port = utils.get_service_port( SERVICE, deploy_options.target, namespace=deploy_options.namespace) with open(SRC_FILE, "r") as src: with open(DST_FILE, "w+") as dst: data = src.read() data = data.replace("REPLACE_URL", '"{}"'.format(service_host)) data = data.replace("REPLACE_PORT", '"{}"'.format(service_port)) data = data.replace("REPLACE_DOMAINS", '"{}"'.format(deploy_options.base_dns_domains)) data = data.replace('REPLACE_NAMESPACE', deploy_options.namespace) print("Deploying {}".format(DST_FILE)) versions = { "IMAGE_BUILDER": "installer-image-build", "AGENT_DOCKER_IMAGE": "agent", "KUBECONFIG_GENERATE_IMAGE": "ignition-manifests-and-kubeconfig-generate", "INSTALLER_IMAGE": "assisted-installer", "CONTROLLER_IMAGE": "assisted-installer-controller", "CONNECTIVITY_CHECK_IMAGE": "connectivity_check", "INVENTORY_IMAGE": "inventory" } for env_var_name, image_short_name in versions.items(): image_fqdn = deployment_options.get_image_override( deploy_options, image_short_name, env_var_name) versions[env_var_name] = image_fqdn # Edge case for controller image override if os.environ.get("INSTALLER_IMAGE" ) and not os.environ.get("CONTROLLER_IMAGE"): versions[ "CONTROLLER_IMAGE"] = deployment_options.IMAGE_FQDN_TEMPLATE.format( "assisted-installer-controller", deployment_options.get_tag( versions["INSTALLER_IMAGE"])) versions["SELF_VERSION"] = deployment_options.get_image_override( deploy_options, "assisted-service", "SERVICE") deploy_tag = get_deployment_tag(deploy_options) if deploy_tag: versions["RELEASE_TAG"] = deploy_tag y = yaml.load(data) y['data'].update(versions) data = yaml.dump(y) dst.write(data) utils.apply(DST_FILE)
def main(): with open(SRC_FILE, "r") as src: with open(DST_FILE, "w+") as dst: data = src.read() print("Deploying {}:\n{}".format(DST_FILE, data)) dst.write(data) utils.apply(DST_FILE)
def main(): with open(SRC_FILE, "r") as src: with open(DST_FILE, "w+") as dst: data = src.read() data = data.replace("REPLACE_IMAGE", os.environ.get("OBJEXP")) print("Deploying {}:\n{}".format(DST_FILE, data)) dst.write(data) utils.apply(DST_FILE)
def main(): utils.verify_build_directory(deploy_options.namespace) with open(SRC_FILE, "r") as src: raw_data = src.read() raw_data = raw_data.replace('REPLACE_NAMESPACE', f'"{deploy_options.namespace}"') raw_data = raw_data.replace('REPLACE_IMAGE_PULL_POLICY', f'"{deploy_options.image_pull_policy}"') data = yaml.safe_load(raw_data) image_fqdn = deployment_options.get_image_override(deploy_options, "assisted-service", "SERVICE") data["spec"]["replicas"] = deploy_options.replicas_count data["spec"]["template"]["spec"]["containers"][0]["image"] = image_fqdn if deploy_options.subsystem_test: if data["spec"]["template"]["spec"]["containers"][0].get("env", None) is None: data["spec"]["template"]["spec"]["containers"][0]["env"] = [] data["spec"]["template"]["spec"]["containers"][0]["env"].append({'name':'CLUSTER_MONITOR_INTERVAL', 'value': TEST_CLUSTER_MONITOR_INTERVAL}) data["spec"]["template"]["spec"]["containers"][0]["env"].append({'name':'HOST_MONITOR_INTERVAL', 'value': TEST_HOST_MONITOR_INTERVAL}) data["spec"]["template"]["spec"]["containers"][0]["env"].append({'name': 'JWKS_CERT', 'value': load_key()}) data["spec"]["template"]["spec"]["containers"][0]["env"].append({'name':'SUBSYSTEM_RUN', 'value': 'True'}) data["spec"]["template"]["spec"]["containers"][0]["env"].append({'name':'DUMMY_IGNITION', 'value': 'True'}) data["spec"]["template"]["spec"]["containers"][0]["env"].append({'name':'OCM_BASE_URL', 'value': WIREMOCK_SERVICE}) data["spec"]["template"]["spec"]["containers"][0]["env"].append({'name':'OCM_TOKEN_URL', 'value': WIREMOCK_SERVICE + '/token'}) data["spec"]["template"]["spec"]["containers"][0]["env"].append({'name':'OCM_SERVICE_CLIENT_ID', 'value': 'mock-ocm-client-id'}) data["spec"]["template"]["spec"]["containers"][0]["env"].append({'name':'OCM_SERVICE_CLIENT_SECRET', 'value': 'mock-ocm-client-secret'}) if deploy_options.target == deployment_options.OPENSHIFT_TARGET: # Images built on infra cluster but needed on ephemeral cluster data["spec"]["template"]["spec"]["containers"][0]["imagePullPolicy"] = "IfNotPresent" else: data["spec"]["template"]["spec"]["containers"][0]["imagePullPolicy"] = "Never" if deploy_options.target == deployment_options.OCP_TARGET: data["spec"]["replicas"] = 1 # force single replica spec = data["spec"]["template"]["spec"] service_container = spec["containers"][0] service_container["env"].append({'name': 'DEPLOY_TARGET', 'value': "ocp"}) service_container["env"].append({'name': 'STORAGE', 'value': "filesystem"}) service_container["env"].append({'name': 'ISO_WORKSPACE_BASE_DIR', 'value': '/data'}) service_container["env"].append({'name': 'ISO_CACHE_DIR', 'value': '/data/cache'}) if deploy_options.port: for port_option in deploy_options.port: port = {"containerPort": int(port_option[0])} data["spec"]["template"]["spec"]["containers"][0]["ports"].append(port) with open(DST_FILE, "w+") as dst: yaml.dump(data, dst, default_flow_style=False) if not deploy_options.apply_manifest: return log.info(f"Deploying {DST_FILE}") utils.apply( target=deploy_options.target, namespace=deploy_options.namespace, file=DST_FILE )
def deploy_postgres(deploy_options): docs = utils.load_yaml_file_docs('deploy/postgres/postgres-deployment.yaml') utils.set_namespace_in_yaml_docs(docs, deploy_options.namespace) dst_file = utils.dump_yaml_file_docs('build/postgres-deployment.yaml', docs) log.info('Deploying %s', dst_file) utils.apply(dst_file)
def deploy_oauth_reqs(): '''oauth Integration in OCP''' ## Token generation for session_secret session_secret = secrets.token_hex(43) secret_name = 'prometheus-k8s-proxy' if not utils.check_if_exists(k8s_object='secret', k8s_object_name=secret_name, target=deploy_options.target, namespace=deploy_options.namespace, profile=deploy_options.profile): cmd = "{} -n {} create secret generic {} --from-literal=session_secret={}" \ .format(CMD_BIN, deploy_options.namespace, secret_name, session_secret) utils.check_output(cmd) ## Annotate Serviceaccount json_manifest = '{"kind":"OAuthRedirectReference","apiVersion":"v1","reference":{"kind":"Route","name":"prometheus-assisted"}}' sa_name = 'prometheus-k8s' annotation_name = 'serviceaccounts.openshift.io/oauth-redirectreference.assisted-installer-prometheus' cmd = "{} -n {} annotate serviceaccount {} --overwrite {}='{}'"\ .format(CMD_BIN, deploy_options.namespace, sa_name, annotation_name, json_manifest) utils.check_output(cmd) # Download OCP Certificate as a secret cert_secret_name = 'openshift-custom-ca' cmd = "{} -n {} get secret {} --no-headers".format( CMD_BIN, deploy_options.namespace, cert_secret_name) cert_secret = utils.check_output(cmd) if not cert_secret: # Get OCP Certificate secret_name = 'router-certs-default' namespace = 'openshift-ingress' template = '{{index .data "tls.crt"}}' cmd = "{} get secret {} --namespace={} --template '{}'"\ .format(CMD_BIN, secret_name, namespace, template) ca_cert = utils.check_output(cmd) # Renderized secret with CA Certificate of the OCP Cluster src_file = os.path.join(os.getcwd(), \ 'deploy/monitoring/prometheus/assisted-installer-ocp-prometheus-custom-ca.yaml') dst_file = os.path.join(os.getcwd(), \ 'build', deploy_options.namespace, 'assisted-installer-ocp-prometheus-custom-ca.yaml') topic = 'OCP Custom CA' with open(src_file, "r") as src: with open(dst_file, "w+") as dst: data = src.read() data = data.replace("BASE64_CERT", ca_cert) data = data.replace('REPLACE_NAMESPACE', f'"{deploy_options.namespace}"') print("Deploying {}: {}".format(topic, dst_file)) dst.write(data) utils.apply(target=deploy_options.target, namespace=deploy_options.namespace, profile=deploy_options.profile, file=dst_file) else: print("Secret {} already exists", cert_secret_name)
def surface(symbol, qdate, qtime=None, errors=False, n=False, loc=0, scale=0): df = query.vols(["*"], ["Date", "Time", "Tenor", "Strike"], symbol, qdate, qtime) st = utils.pack(df) del df #---------------------------------------------------------------------------------- f = lambda LST: pricer.norm_weights(LST, loc, scale) wgt = utils.apply(f, 1, st, ["Time", "Tenor"], ["LogStrike"]) #retrive weights vector sv = pricer.SSVI(errors) f = lambda LST, VAR, TNR, VOL: sv.calibrate(LST, VAR, TNR, VOL, wgt) if errors == True: prm = utils.apply(f, 6, st, ["Time"], ["LogStrike", "TotAtmfVar", "Tenor", "SmtVol"], diff=True, fill=False) eps = prm[-1] prm = np.asarray(prm[:-1]).T else: prm = utils.apply(f, 5, st, ["Time"], ["LogStrike", "TotAtmfVar", "Tenor", "SmtVol"], fill=False) #---------------------------------------------------------------------------------- reduced = [ "Time", "Group", "Tenor", "SpotMid", "Forward", "CumDivDays", "Div", "ImpBor", "Rate", "CallH0", "CallH1", "CallKh", "PutH0", "PutH1", "PutKh", "TotAtmfVar" ] st = utils.unique_nosort(st[reduced]) prm = utils.restack(prm, st["TotAtmfVar"], tile=False) rho = sv.correlation(st["TotAtmfVar"], prm[:, 0], prm[:, 1], prm[:, 2]) phi = sv.power_law(st["TotAtmfVar"], prm[:, 3], prm[:, 4]) atm, skw, krt = sv.raw2jw(st["Tenor"] / base, st["TotAtmfVar"], phi, rho) arr = unstruct(st) arr = np.column_stack([arr, atm, skw, krt, phi, rho]) df = utils.unpack(arr, qdate, raw=False, symbol=symbol) if errors == True and n == False: return df, eps elif errors == False and n == True: return df, n elif errors == True and n == True: return df, eps, n else: return df
def main(): SRC_FILE = os.path.join(os.getcwd(), "deploy/namespace/namespace.yaml") DST_FILE = os.path.join(os.getcwd(), "build/namespace.yaml") with open(SRC_FILE, "r") as src: with open(DST_FILE, "w+") as dst: data = src.read() print("Deploying {}:\n{}".format(DST_FILE, data)) dst.write(data) utils.apply(DST_FILE)
def main(): utils.verify_build_directory(deploy_options.namespace) src_file = os.path.join(os.getcwd(), 'deploy/assisted-service-service.yaml') dst_file = os.path.join(os.getcwd(), 'build', deploy_options.namespace, 'assisted-service-service.yaml') with open(src_file, "r") as src: with open(dst_file, "w+") as dst: raw_data = src.read() raw_data = raw_data.replace('REPLACE_NAMESPACE', f'"{deploy_options.namespace}"') data = yaml.safe_load(raw_data) if deploy_options.port: for port_number_str, port_name in deploy_options.port: port = { "name": port_name, "port": int(port_number_str), "protocol": "TCP", "targetPort": int(port_number_str) } data["spec"]["ports"].append(port) print("Deploying {}".format(dst_file)) dst.write(yaml.dump(data)) if deploy_options.apply_manifest: utils.apply(target=deploy_options.target, namespace=deploy_options.namespace, file=dst_file) # in case of OpenShift deploy ingress as well if deploy_options.target == "oc-ingress": hostname = utils.get_service_host('assisted-installer', deploy_options.target, deploy_options.domain, deploy_options.namespace) if deploy_options.disable_tls: template = "assisted-installer-ingress.yaml" else: print( "WARNING: On OpenShift, in order to change TLS redirection behavior update " "spec/tls/insecureEdgeTerminationPolicy (None|Allow|Redirect) " "in the corresponding OpenShift route") deploy_tls_secret.generate_secret( output_dir=os.path.join(os.getcwd(), "build"), service="assisted-service", san=hostname, namespace=deploy_options.namespace) template = "assisted-installer-ingress-tls.yaml" deploy_ingress(hostname=hostname, namespace=deploy_options.namespace, template_file=template)
def main(): src_file = os.path.join(os.getcwd(), "deploy/s3/scality-deployment.yaml") dst_file = os.path.join(os.getcwd(), "build/scality-deployment.yaml") with open(src_file, "r") as src: with open(dst_file, "w+") as dst: data = src.read() print("Deploying {}".format(dst_file)) dst.write(data) utils.apply("deploy/s3/scality-storage.yaml") utils.apply(dst_file)
def deploy_wiremock(deploy_options): docs = utils.load_yaml_file_docs( 'deploy/wiremock/wiremock-deployment.yaml') utils.set_namespace_in_yaml_docs(docs, deploy_options.namespace) dst_file = utils.dump_yaml_file_docs('build/wiremock-deployment.yaml', docs) log.info('Deploying %s', dst_file) utils.apply(target=deploy_options.target, namespace=deploy_options.namespace, file=dst_file)
def main(): deploy_options = handle_arguments() utils.set_profile(deploy_options.target, deploy_options.profile) with open(SRC_FILE, "r") as src: with open(DST_FILE, "w+") as dst: data = src.read() data = data.replace("REPLACE_DOMAINS", '"{}"'.format(deploy_options.base_dns_domains)) data = data.replace("REPLACE_BASE_URL", utils.get_service_url(service=SERVICE, target=deploy_options.target, domain=deploy_options.domain, namespace=deploy_options.namespace, profile=deploy_options.profile, disable_tls=deploy_options.disable_tls)) data = data.replace('REPLACE_NAMESPACE', deploy_options.namespace) data = data.replace('REPLACE_AUTH_ENABLED_FLAG', '"{}"'.format(deploy_options.enable_auth)) data = data.replace('REPLACE_JWKS_URL', '"{}"'.format(deploy_options.jwks_url)) data = data.replace('REPLACE_OCM_BASE_URL', '"{}"'.format(deploy_options.ocm_url)) print("Deploying {}".format(DST_FILE)) subsystem_versions = {"IMAGE_BUILDER": "ISO_CREATION", "IGNITION_GENERATE_IMAGE": "DUMMY_IGNITION"} versions = {"IMAGE_BUILDER": "assisted-iso-create", "IGNITION_GENERATE_IMAGE": "assisted-ignition-generator", "INSTALLER_IMAGE": "assisted-installer", "CONTROLLER_IMAGE": "assisted-installer-controller", "AGENT_DOCKER_IMAGE": "assisted-installer-agent", "CONNECTIVITY_CHECK_IMAGE": "assisted-installer-agent", "INVENTORY_IMAGE": "assisted-installer-agent"} for env_var_name, image_short_name in versions.items(): if deploy_options.subsystem_test and env_var_name in subsystem_versions.keys(): image_fqdn = deployment_options.get_image_override(deploy_options, image_short_name, subsystem_versions[env_var_name]) else: image_fqdn = deployment_options.get_image_override(deploy_options, image_short_name, env_var_name) versions[env_var_name] = image_fqdn # Edge case for controller image override if os.environ.get("INSTALLER_IMAGE") and not os.environ.get("CONTROLLER_IMAGE"): versions["CONTROLLER_IMAGE"] = deployment_options.IMAGE_FQDN_TEMPLATE.format("assisted-installer-controller", deployment_options.get_tag(versions["INSTALLER_IMAGE"])) versions["SELF_VERSION"] = deployment_options.get_image_override(deploy_options, "assisted-service", "SERVICE") deploy_tag = get_deployment_tag(deploy_options) if deploy_tag: versions["RELEASE_TAG"] = deploy_tag y = yaml.load(data) y['data'].update(versions) data = yaml.dump(y) dst.write(data) utils.apply(DST_FILE)
def deployer(src_file, topic): '''Wrapper for oc/kubectl apply -f''' src_file = os.path.join(os.getcwd(), src_file) dst_file = os.path.join(os.getcwd(), 'build', os.path.basename(src_file)) with open(src_file) as fp: data = fp.read() data = data.replace('REPLACE_NAMESPACE', deploy_options.namespace) with open(dst_file, 'w') as fp: fp.write(data) print("Deploying {}: {}".format(topic, dst_file)) utils.apply(dst_file)
def main(): SRC_FILE = os.path.join(os.getcwd(), "deploy/s3/scality-deployment.yaml") DST_FILE = os.path.join(os.getcwd(), "build/scality-deployment.yaml") with open(SRC_FILE, "r") as src: with open(DST_FILE, "w+") as dst: data = src.read() print("Deploying {}:\n{}".format(DST_FILE, data)) dst.write(data) utils.apply("deploy/s3/scality-storage.yaml") utils.apply(DST_FILE)
def deploy_ingress(hostname, namespace, template_file): src_file = os.path.join(os.getcwd(), "deploy", template_file) dst_file = os.path.join(os.getcwd(), "build", template_file) with open(src_file, "r") as src: with open(dst_file, "w+") as dst: data = src.read() data = data.replace('REPLACE_NAMESPACE', namespace) data = data.replace("REPLACE_HOSTNAME", hostname) print("Deploying {}".format(dst_file)) dst.write(data) utils.apply(dst_file)
def main(): src_file = os.path.join(os.getcwd(), "deploy/roles/default_role.yaml") dst_file = os.path.join(os.getcwd(), "build/default_role.yaml") with open(src_file, "r") as src: with open(dst_file, "w+") as dst: data = src.read() print("Deploying {}".format(dst_file)) dst.write(data) utils.apply(dst_file)
def main(): src_file = os.path.join(os.getcwd(), "deploy/s3/scality-configmap.yaml") dst_file = os.path.join(os.getcwd(), "build/scality-configmap.yaml") scality_url = "http://cloudserver-front:8000" with open(src_file, "r") as src: with open(dst_file, "w+") as dst: data = src.read() data = data.replace('REPLACE_URL', scality_url) print("Deploying {}".format(dst_file)) dst.write(data) utils.apply(dst_file)
def main(): service_host = utils.get_service_host(SERVICE) service_port = utils.get_service_port(SERVICE) with open(SRC_FILE, "r") as src: with open(DST_FILE, "w+") as dst: data = src.read() data = data.replace("REPLACE_URL", '"{}"'.format(service_host)) data = data.replace("REPLACE_PORT", '"{}"'.format(service_port)) print("Deploying {}:\n{}".format(DST_FILE, data)) dst.write(data) utils.apply(DST_FILE)
def main(): scality_url = utils.get_service_url(SERVICE) scality_host = utils.get_service_host(SERVICE) with open(SRC_FILE, "r") as src: with open(DST_FILE, "w+") as dst: data = src.read() data = data.replace('REPLACE_URL', scality_url) data = data.replace('REPLACE_HOST_NAME', scality_host) print("Deploying {}:\n{}".format(DST_FILE, data)) dst.write(data) utils.apply(DST_FILE)
def sendMessages(self, init=False): """ Sends messages from vk to xmpp and call message01 handlers Paramteres: init: needed to know if function called at init (add time or not) Plugins notice (msg01): If plugin returs None then message will not be sent by transport's core, it shall be sent by plugin itself Otherwise, if plugin returns string, it will be sent by transport's core """ with self.__sync: date = 0 messages = self.vk.getMessages(20, self.lastMsgID) if not messages or not messages[0]: return None messages = sorted(messages[1:], sortMsg) for message in messages: if message["out"]: continue Stats["msgin"] += 1 fromjid = vk2xmpp(message["uid"]) body = uHTML(message["body"]) iter = Handlers["msg01"].__iter__() for func in iter: try: result = func(self, message) except Exception: result = None crashLog("handle.%s" % func.__name__) if result is None: for func in iter: utils.apply(func, (self, message)) break else: body += result else: if init: date = message["date"] sendMessage(Component, self.source, fromjid, escape("", body), date) if messages: self.lastMsgID = messages[-1]["mid"] try: self.updateLastMsgID(Semaphore) except sqlite3.OperationalError, e: logger.error("User:sendmessages error %s occurred while updating last message id (jid: %s)" % (str(e), self.source))
def recognize(self, figure): self.X = [figure] iters = 0 while iters<MAX_ITERS: new = apply(multiply(self.X, self.w), sign) if self.X == new: break self.X = new iters+=1 if iters==MAX_ITERS: return (False, self.X, iters) return (True, self.X, iters)