def create_grafane_subdomain(self): self.workload_ids = [] metadata = { "name": self.config.release_name, "form_info": { "chatflow": self.SOLUTION_TYPE, "Solution name": self.config.release_name }, } self.config.chart_config.grafana_domain = f"grafana-{self.config.chart_config.domain}" self.workload_ids.append( deployer.create_subdomain( pool_id=self.gateway_pool.pool_id, gateway_id=self.gateway.node_id, subdomain=self.config.chart_config.grafana_domain, addresses=[self.vdc_info["public_ip"]], solution_uuid=self.solution_id, identity_name=self.identity_name, **metadata, )) success = deployer.wait_workload(self.workload_ids[0], self) if not success: raise DeploymentFailed( f"Failed to create subdomain {self.config.chart_config.grafana_domain} on gateway {self.gateway.node_id} {self.workload_ids[0]}. The resources you paid for will be re-used in your upcoming deployments.", wid=self.workload_ids[0], )
def _deploy(self): metadata = { "name": self.solution_name, "form_info": { "chatflow": self.SOLUTION_TYPE, "Solution name": self.solution_name }, } self.solution_metadata.update(metadata) env = { "pub_key": "", "DISCOURSE_VERSION": "staging", "RAILS_ENV": "production", "DISCOURSE_HOSTNAME": self.domain, "DISCOURSE_SMTP_USER_NAME": self.smtp_username, "DISCOURSE_SMTP_ADDRESS": self.smtp_server, "DISCOURSE_DEVELOPER_EMAILS": self.user_email, "DISCOURSE_SMTP_PORT": "587", "THREEBOT_URL": "https://login.threefold.me", "OPEN_KYC_URL": "https://openkyc.live/verification/verify-sei", "UNICORN_BIND_ALL": "true", } threebot_private_key = nacl.signing.SigningKey.generate().encode( nacl.encoding.Base64Encoder).decode("utf-8") secret_env = { "THREEBOT_PRIVATE_KEY": threebot_private_key, "FLASK_SECRET_KEY": j.data.idgenerator.guid(), "DISCOURSE_SMTP_PASSWORD": self.smtp_password, } # reserve subdomain _id = deployer.create_subdomain( pool_id=self.gateway_pool.pool_id, gateway_id=self.gateway.node_id, subdomain=self.domain, addresses=self.addresses, solution_uuid=self.solution_id, **self.solution_metadata, ) success = deployer.wait_workload(_id, self) if not success: raise DeploymentFailed( f"Failed to create subdomain {self.domain} on gateway" f" {self.gateway.node_id} {_id}. The resources you paid for will be re-used in your upcoming deployments.", wid=_id, ) self.threebot_url = f"https://{self.domain}" entrypoint = f"/.start_discourse.sh" # reserve container self.resv_id = deployer.deploy_container( pool_id=self.pool_id, node_id=self.selected_node.node_id, network_name=self.network_view.name, ip_address=self.ip_address, flist=self.FLIST_URL, cpu=self.container_resources["cru"], memory=self.container_resources["mru"] * 1024, disk_size=self.container_resources["sru"] * 1024, entrypoint=entrypoint, env=env, secret_env=secret_env, interactive=False, **self.solution_metadata, solution_uuid=self.solution_id, ) success = deployer.wait_workload(self.resv_id, self) if not success: raise DeploymentFailed( f"Failed to deploy workload {self.resv_id}. The resources you paid for will be re-used in your upcoming deployments.", solution_uuid=self.solution_id, wid=self.resv_id, ) _id, _ = deployer.expose_and_create_certificate( pool_id=self.pool_id, gateway_id=self.gateway.node_id, network_name=self.network_view.name, trc_secret=self.secret, domain=self.domain, email=self.user_email, solution_ip=self.ip_address, solution_port=80, enforce_https=True, node_id=self.selected_node.node_id, solution_uuid=self.solution_id, proxy_pool_id=self.gateway_pool.pool_id, log_config=self.nginx_log_config, **self.solution_metadata, ) success = deployer.wait_workload(_id, self) if not success: raise DeploymentFailed( f"Failed to create TRC container on node {self.selected_node.node_id} {_id}. The resources you paid for will be re-used in your upcoming deployments.", solution_uuid=self.solution_id, wid=_id, )
def reservation(self): var_dict = { "MYSQL_ROOT_PASSWORD": "******", "MYSQL_USER": "******", "MYSQL_PASSWORD": "******", "MYSQL_DATABASE": "mattermost_db", } metadata = { "name": self.solution_name, "form_info": { "Solution name": self.solution_name, "Domain name": self.domain, "chatflow": self.SOLUTION_TYPE, }, } self.solution_metadata.update(metadata) # reserve subdomain _id = deployer.create_subdomain( pool_id=self.gateway_pool.pool_id, gateway_id=self.gateway.node_id, subdomain=self.domain, addresses=self.addresses, solution_uuid=self.solution_id, **self.solution_metadata, ) success = deployer.wait_workload(_id, self) if not success: raise DeploymentFailed( f"Failed to create subdomain {self.domain} on gateway" f" {self.gateway.node_id} {_id}. The resources you paid for will be re-used in your upcoming deployments." ) self.solution_url = f"https://{self.domain}" # create volume vol_mount_point = "/var/lib/mysql/" volume_config = {} vol_id = deployer.deploy_volume( self.pool_id, self.selected_node.node_id, self.vol_size, solution_uuid=self.solution_id, **self.solution_metadata, ) success = deployer.wait_workload(vol_id, self) if not success: raise DeploymentFailed( f"Failed to deploy volume on node {self.selected_node.node_id} {vol_id}. The resources you paid for will be re-used in your upcoming deployments.", solution_uuid=self.solution_id, wid=vol_id, ) volume_config[vol_mount_point] = vol_id # Create container self.resv_id = deployer.deploy_container( pool_id=self.pool_id, node_id=self.selected_node.node_id, network_name=self.network_view.name, ip_address=self.ip_address, flist=self.FLIST_URL, cpu=self.query["cru"], memory=self.query["mru"] * 1024, disk_size=(self.query["sru"] - self.vol_size) * 1024, env=var_dict, interactive=False, entrypoint="/start_mattermost.sh", volumes=volume_config, public_ipv6=True, solution_uuid=self.solution_id, **self.solution_metadata, ) success = deployer.wait_workload(self.resv_id, self) if not success: raise DeploymentFailed( f"Failed to deploy workload {self.resv_id}. The resources you paid for will be re-used in your upcoming deployments.", solution_uuid=self.solution_id, wid=self.resv_id, ) # expose threebot container _id = deployer.expose_and_create_certificate( pool_id=self.pool_id, gateway_id=self.gateway.node_id, network_name=self.network_view.name, trc_secret=self.secret, domain=self.domain, email=self.user_email, solution_ip=self.ip_address, solution_port=8065, enforce_https=False, node_id=self.selected_node.node_id, solution_uuid=self.solution_id, **self.solution_metadata, ) success = deployer.wait_workload(_id, self) if not success: raise DeploymentFailed( f"Failed to create TRC container on node {self.selected_node.node_id}" f" {_id}. The resources you paid for will be re-used in your upcoming deployments.", solution_uuid=self.solution_id, wid=_id, )
def _deploy(self): # 1- add node to network metadata = { "form_info": { "Solution name": self.solution_name, "chatflow": "threebot" } } self.solution_metadata.update(metadata) self.workload_ids = [] deploying_message = f"""\ # Deploying your 3Bot...\n\n <br>It will usually take a few minutes to succeed. Please wait patiently.\n You will be automatically redirected to the next step once succeeded. """ self.md_show_update(dedent(deploying_message), md=True) # 2- reserve subdomain if not self.custom_domain: self.workload_ids.append( deployer.create_subdomain( pool_id=self.gateway_pool.pool_id, gateway_id=self.gateway.node_id, subdomain=self.domain, addresses=self.addresses, solution_uuid=self.solution_id, identity_name=self.identity_name, **self.solution_metadata, )) success = deployer.wait_workload(self.workload_ids[-1], identity_name=self.identity_name) if not success: raise DeploymentFailed( f"Failed to create subdomain {self.domain} on gateway {self.gateway.node_id} {self.workload_ids[-1]}. The resources you paid for will be re-used in your upcoming deployments.", wid=self.workload_ids[-1], identity_name=self.identity_name, ) # Deploy proxy proxy_id = deployer.create_proxy( self.gateway_pool.pool_id, self.gateway.node_id, self.domain, self.secret, self.identity_name, **self.solution_metadata, ) self.workload_ids.append(proxy_id) success = deployer.wait_workload(self.workload_ids[-1], identity_name=self.identity_name) if not success: raise DeploymentFailed( f"Failed to create proxy with wid: {self.workload_ids[-1]}. The resources you paid for will be re-used in your upcoming deployments.", solution_uuid=self.solution_id, wid=self.workload_ids[-1], identity_name=self.identity_name, ) test_cert = j.config.get("TEST_CERT") # Generate a one-time token to create a user for backup backup_token = str(j.data.idgenerator.idgenerator.uuid.uuid4()) self.backup_model.token = backup_token self.backup_model.tname = self.solution_metadata["owner"] self.backup_model.save() # 3- deploy threebot container if "test" in j.core.identity.me.explorer_url: default_identity = "test" elif "dev" in j.core.identity.me.explorer_url: default_identity = "dev" else: default_identity = "main" environment_vars = { "SDK_VERSION": self.branch, "INSTANCE_NAME": self.solution_name, "THREEBOT_NAME": self.threebot_name, "DOMAIN": self.domain, "SSHKEY": self.public_key, "TEST_CERT": "true" if test_cert else "false", "MARKETPLACE_URL": f"https://{j.sals.nginx.main.websites.threebot_deployer_threebot_deployer_root_proxy_443.domain}/", "DEFAULT_IDENTITY": default_identity, # email settings "EMAIL_HOST": "", "EMAIL_HOST_USER": "", "ESCALATION_MAIL": "", # TRC "REMOTE_IP": f"{self.gateway.dns_nameserver[0]}", "REMOTE_PORT": f"{self.gateway.tcp_router_port}", "ACME_SERVER_URL": j.core.config.get("VDC_ACME_SERVER_URL", "https://ca1.grid.tf"), } self.network_view = self.network_view.copy() ## Container logs log_config = j.core.config.get("LOGGING_SINK", {}) if log_config: log_config[ "channel_name"] = f"{self.threebot_name}-{self.SOLUTION_TYPE}-{self.solution_name}".lower( ) # Create wallet for the 3bot threebot_wallet = j.clients.stellar.get( f"{self.SOLUTION_TYPE}_{self.threebot_name}_{self.solution_name}") threebot_wallet.save() threebot_wallet_secret = threebot_wallet.secret try: threebot_wallet.activate_through_threefold_service() except Exception as e: j.logger.warning( f"Failed to activate wallet for {self.threebot_name} {self.solution_name} threebot due to {str(e)}" "3Bot will start without a wallet") threebot_wallet_secret = "" self.workload_ids.append( deployer.deploy_container( pool_id=self.pool_id, node_id=self.selected_node.node_id, network_name=self.network_view.name, ip_address=self.ip_address, flist=self.FLIST_URL[self.branch], env=environment_vars, cpu=self.query["cru"], memory=self.query["mru"] * 1024, disk_size=self.query["sru"] * 1024, secret_env={ "BACKUP_PASSWORD": self.backup_password, "BACKUP_TOKEN": backup_token, "EMAIL_HOST_PASSWORD": "", "TRC_SECRET": self.secret, "THREEBOT_WALLET_SECRET": threebot_wallet_secret, }, interactive=False, log_config=log_config, solution_uuid=self.solution_id, identity_name=self.identity_name, **self.solution_metadata, )) success = deployer.wait_workload(self.workload_ids[-1], identity_name=self.identity_name) if not success: raise DeploymentFailed( f"Failed to create container on node {self.selected_node.node_id} {self.workload_ids[-1]}. The resources you paid for will be re-used in your upcoming deployments.", solution_uuid=self.solution_id, wid=self.workload_ids[-1], identity_name=self.identity_name, ) self.threebot_url = f"https://{self.domain}/admin" instance_name = f"threebot_{self.solution_id}" user_threebot = USER_THREEBOT_FACTORY.get(instance_name) user_threebot.solution_uuid = self.solution_id user_threebot.identity_tid = j.core.identity.get( self.identity_name).tid user_threebot.name = self.solution_name user_threebot.owner_tname = self.threebot_name user_threebot.farm_name = self.farm_name user_threebot.state = ThreebotState.RUNNING if hasattr(self, "continent"): user_threebot.continent = self.continent if not self.custom_domain: user_threebot.subdomain_wid = self.workload_ids[-3] user_threebot.proxy_wid = self.workload_ids[-2] user_threebot.threebot_container_wid = self.workload_ids[-1] user_threebot.explorer_url = j.core.identity.get( self.identity_name).explorer_url user_threebot.hash_secret(self.backup_password) user_threebot.save()
def _deploy(self): metadata = { "name": self.solution_name, "form_info": { "chatflow": self.SOLUTION_TYPE, "Solution name": self.solution_name }, } self.solution_metadata.update(metadata) # deploy volume vol_id = deployer.deploy_volume( self.pool_id, self.selected_node.node_id, self.vol_size, solution_uuid=self.solution_id, **self.solution_metadata, ) success = deployer.wait_workload(vol_id, self) if not success: raise DeploymentFailed( f"Failed to deploy volume on node {self.selected_node.node_id} {vol_id}. The resources you paid for will be re-used in your upcoming deployments.", wid=vol_id, ) volume_config = {self.vol_mount_point: vol_id} # reserve subdomain _id = deployer.create_subdomain( pool_id=self.gateway_pool.pool_id, gateway_id=self.gateway.node_id, subdomain=self.domain, addresses=self.addresses, solution_uuid=self.solution_id, **self.solution_metadata, ) success = deployer.wait_workload(_id, self) if not success: raise DeploymentFailed( f"Failed to create subdomain {self.domain} on gateway" f" {self.gateway.node_id} {_id}. The resources you paid for will be re-used in your upcoming deployments.", solution_uuid=self.solution_id, wid=_id, ) self.threebot_url = f"http://{self.domain}" entrypoint = f'/usr/local/bin/startup.sh "{self.domain}"' self.entrypoint = entrypoint # reserve container self.resv_id = deployer.deploy_container( pool_id=self.pool_id, node_id=self.selected_node.node_id, network_name=self.network_view.name, ip_address=self.ip_address, flist=self.FLIST_URL, cpu=self.container_resources["cru"], memory=self.container_resources["mru"] * 1024, disk_size=self.container_resources["sru"] * 1024, entrypoint=entrypoint, volumes=volume_config, interactive=False, **self.solution_metadata, solution_uuid=self.solution_id, ) success = deployer.wait_workload(self.resv_id, self) if not success: raise DeploymentFailed( f"Failed to deploy workload {self.resv_id}. The resources you paid for will be re-used in your upcoming deployments.", solution_uuid=self.solution_id, wid=self.resv_id, ) _id, _ = deployer.expose_and_create_certificate( pool_id=self.pool_id, gateway_id=self.gateway.node_id, network_name=self.network_view.name, trc_secret=self.secret, domain=self.domain, email=self.user_email, solution_ip=self.ip_address, solution_port=80, enforce_https=True, node_id=self.selected_node.node_id, solution_uuid=self.solution_id, proxy_pool_id=self.gateway_pool.pool_id, log_config=self.nginx_log_config, **self.solution_metadata, ) success = deployer.wait_workload(_id, self) if not success: raise DeploymentFailed( f"Failed to create TRC container on node {self.selected_node.node_id} {_id}. The resources you paid for will be re-used in your upcoming deployments.", solution_uuid=self.solution_id, wid=_id, )
def reservation(self): self.database_name = "gitea" self.database_user = "******" self.database_password = uuid.uuid4().hex self.repository_name = self.solution_name var_dict = { "POSTGRES_DB": self.database_name, "DB_TYPE": "postgres", "DB_HOST": "localhost:5432", "POSTGRES_USER": self.database_user, "APP_NAME": self.repository_name, "ROOT_URL": f"https://{self.domain}", "HTTP_PORT": "3000", "DOMAIN": f"{self.domain}", } metadata = { "name": self.solution_name, "form_info": {"Solution name": self.solution_name, "chatflow": "gitea",}, } self.solution_metadata.update(metadata) # reserve subdomain subdomain_wid = deployer.create_subdomain( pool_id=self.pool_id, gateway_id=self.gateway.node_id, subdomain=self.domain, addresses=self.addresses, solution_uuid=self.solution_id, **self.solution_metadata, ) subdomain_wid = deployer.wait_workload(subdomain_wid, self) if not subdomain_wid: raise DeploymentFailed( f"Failed to create subdomain {self.domain} on gateway {self.gateway.node_id} {subdomain_wid}. The resources you paid for will be re-used in your upcoming deployments." ) self.resv_id = deployer.deploy_container( pool_id=self.pool_id, node_id=self.selected_node.node_id, network_name=self.network_view.name, ip_address=self.ip_address, flist=self.FLIST_URL, cpu=self.query["cru"], memory=self.query["mru"] * 1024, env=var_dict, interactive=False, entrypoint="/start_gitea.sh", public_ipv6=True, disk_size=self.query["sru"] * 1024, secret_env={"POSTGRES_PASSWORD": self.database_password}, solution_uuid=self.solution_id, **self.solution_metadata, ) success = deployer.wait_workload(self.resv_id, self) if not success: solutions.cancel_solution(self.solution_metadata["owner"], [self.resv_id]) raise DeploymentFailed( f"Failed to deploy workload {self.resv_id}. The resources you paid for will be re-used in your upcoming deployments.", solution_uuid=self.solution_id, wid=self.resv_id, ) self.reverse_proxy_id = deployer.expose_and_create_certificate( pool_id=self.pool_id, gateway_id=self.gateway.node_id, network_name=self.network_view.name, trc_secret=self.secret, domain=self.domain, email=self.user_info()["email"], solution_ip=self.ip_address, solution_port=3000, enforce_https=True, node_id=self.selected_node.node_id, solution_uuid=self.solution_id, proxy_pool_id=self.gateway_pool.pool_id, **self.solution_metadata, ) success = deployer.wait_workload(self.reverse_proxy_id) if not success: solutions.cancel_solution(self.solution_metadata["owner"], [self.reverse_proxy_id]) raise DeploymentFailed( f"Failed to reserve TCP Router container workload {self.reverse_proxy_id}. The resources you paid for will be re-used in your upcoming deployments.", solution_uuid=self.solution_id, wid=self.reverse_proxy_id, )
def reservation(self): self.workload_ids = [] metadata = { "name": self.solution_name, "form_info": { "chatflow": self.SOLUTION_TYPE, "Solution name": self.solution_name }, } self.solution_metadata.update(metadata) # reserve subdomain self.workload_ids.append( deployer.create_subdomain( pool_id=self.pool_id, gateway_id=self.gateway.node_id, subdomain=self.domain, addresses=self.addresses, solution_uuid=self.solution_id, **self.solution_metadata, )) success = deployer.wait_workload(self.workload_ids[0], self) if not success: raise DeploymentFailed( f"Failed to create subdomain {self.domain} on gateway {self.gateway.node_id} {self.workload_ids[0]}. The resources you paid for will be re-used in your upcoming deployments.", ) # deploy volume vol_id = deployer.deploy_volume( self.pool_id, self.selected_node.node_id, self.vol_size, solution_uuid=self.solution_id, **self.solution_metadata, ) success = deployer.wait_workload(vol_id, self) if not success: raise DeploymentFailed( f"Failed to deploy volume on node {self.selected_node.node_id} {vol_id}. The resources you paid for will be re-used in your upcoming deployments.", solution_uuid=self.solution_id, wid=vol_id, ) volume_config = {self.vol_mount_point: vol_id} # deploy container var_dict = { "size": str(self.vol_size * 1024), # in MBs } self.workload_ids.append( deployer.deploy_container( pool_id=self.pool_id, node_id=self.selected_node.node_id, network_name=self.network_view.name, ip_address=self.ip_address, flist=self.FLIST_URL, cpu=self.query["cru"], memory=self.query["mru"] * 1024, disk_size=(self.query["sru"] - self.vol_size) * 1024, volumes=volume_config, env=var_dict, interactive=False, entrypoint="/start.sh", solution_uuid=self.solution_id, **self.solution_metadata, )) self.resv_id = self.workload_ids[-1] success = deployer.wait_workload(self.workload_ids[-1], self) if not success: raise DeploymentFailed( f"Failed to create container on node {self.selected_node.node_id} {self.workload_ids[-1]}. The resources you paid for will be re-used in your upcoming deployments.", solution_uuid=self.solution_id, wid=self.workload_ids[-1], ) # expose solution on nginx container _id = deployer.expose_and_create_certificate( pool_id=self.pool_id, gateway_id=self.gateway.node_id, network_name=self.network_view.name, trc_secret=self.secret, domain=self.domain, email=self.user_email, solution_ip=self.ip_address, solution_port=3000, enforce_https=False, node_id=self.selected_node.node_id, solution_uuid=self.solution_id, **self.solution_metadata, ) success = deployer.wait_workload(_id, self) if not success: # solutions.cancel_solution(self.workload_ids) raise DeploymentFailed( f"Failed to create TRC container on node {self.selected_node.node_id}" f" {_id}. The resources you paid for will be re-used in your upcoming deployments.", solution_uuid=self.solution_id, wid=self.workload_ids[-1], )
def _deploy(self): var_dict = { "POSTGRES_DB": self.database_name, "DB_TYPE": "postgres", "DB_HOST": "localhost:5432", "POSTGRES_USER": self.database_user, "APP_NAME": self.repository_name, "ROOT_URL": f"https://{self.domain}", "HTTP_PORT": "3000", "DOMAIN": f"{self.domain}", "pub_key": self.public_key, } metadata = { "name": self.solution_name, "form_info": {"Solution name": self.solution_name, "chatflow": "gitea",}, } self.solution_metadata.update(metadata) # reserve subdomain if not self.custom_domain: subdomain_wid = deployer.create_subdomain( pool_id=self.gateway_pool.pool_id, gateway_id=self.gateway.node_id, subdomain=self.domain, addresses=self.addresses, solution_uuid=self.solution_id, **self.solution_metadata, ) subdomain_wid = deployer.wait_workload(subdomain_wid, self) if not subdomain_wid: raise DeploymentFailed( f"Failed to create subdomain {self.domain} on gateway {self.gateway.node_id} {subdomain_wid}. The resources you paid for will be re-used in your upcoming deployments.", wid=subdomain_wid, ) secret_env = { "AWS_ACCESS_KEY_ID": self.aws_access_key_id, "AWS_SECRET_ACCESS_KEY": self.aws_secret_access_key, "RESTIC_PASSWORD": self.restic_password, "RESTIC_REPOSITORY": self.restic_repository, "CRON_FREQUENCY": "0 0 * * *", # every 1 day "POSTGRES_PASSWORD": self.database_password, } self.resv_id = deployer.deploy_container( pool_id=self.pool_id, node_id=self.selected_node.node_id, network_name=self.network_view.name, ip_address=self.ip_address, flist=self.FLIST_URL, cpu=self.resources["cru"], memory=self.resources["mru"] * 1024, env=var_dict, interactive=False, entrypoint="/start_gitea.sh", public_ipv6=True, disk_size=self.resources["sru"] * 1024, secret_env=secret_env, solution_uuid=self.solution_id, **self.solution_metadata, ) success = deployer.wait_workload(self.resv_id, self) if not success: solutions.cancel_solution(self.solution_metadata["owner"], [self.resv_id]) raise DeploymentFailed( f"Failed to deploy workload {self.resv_id}. The resources you paid for will be re-used in your upcoming deployments.", solution_uuid=self.solution_id, wid=self.resv_id, ) self.reverse_proxy_id, _ = deployer.expose_and_create_certificate( pool_id=self.pool_id, gateway_id=self.gateway.node_id, network_name=self.network_view.name, trc_secret=self.secret, domain=self.domain, email=self.user_email, solution_ip=self.ip_address, solution_port=3000, enforce_https=True, node_id=self.selected_node.node_id, solution_uuid=self.solution_id, proxy_pool_id=self.gateway_pool.pool_id, log_config=self.nginx_log_config, **self.solution_metadata, ) success = deployer.wait_workload(self.reverse_proxy_id) if not success: solutions.cancel_solution(self.solution_metadata["owner"], [self.reverse_proxy_id]) raise DeploymentFailed( f"Failed to reserve TCP Router container workload {self.reverse_proxy_id}. The resources you paid for will be re-used in your upcoming deployments.", solution_uuid=self.solution_id, wid=self.reverse_proxy_id, )
def _deploy(self): self.workload_ids = [] metadata = { "name": self.solution_name, "form_info": { "chatflow": self.SOLUTION_TYPE, "Solution name": self.solution_name }, } self.solution_metadata.update(metadata) if not self.custom_domain: # reserve subdomain self.workload_ids.append( deployer.create_subdomain( pool_id=self.gateway_pool.pool_id, gateway_id=self.gateway.node_id, subdomain=self.domain, addresses=self.addresses, solution_uuid=self.solution_id, **self.solution_metadata, )) success = deployer.wait_workload(self.workload_ids[0], self) if not success: raise DeploymentFailed( f"Failed to create subdomain {self.domain} on gateway {self.gateway.node_id} {self.workload_ids[0]}. The resources you paid for will be re-used in your upcoming deployments.", wid=self.workload_ids[0], ) # deploy volume vol_id = deployer.deploy_volume( self.pool_id, self.selected_node.node_id, self.vol_size, solution_uuid=self.solution_id, **self.solution_metadata, ) success = deployer.wait_workload(vol_id, self) if not success: raise DeploymentFailed( f"Failed to deploy volume on node {self.selected_node.node_id} {vol_id}. The resources you paid for will be re-used in your upcoming deployments.", solution_uuid=self.solution_id, wid=vol_id, ) volume_config = {self.vol_mount_point: vol_id} # deploy container var_dict = { "size": str(self.vol_size * 1024), "pub_key": self.public_key } # in MBs secret_env = { "AWS_ACCESS_KEY_ID": self.aws_access_key_id, "AWS_SECRET_ACCESS_KEY": self.aws_secret_access_key, "RESTIC_PASSWORD": self.restic_password, "RESTIC_REPOSITORY": self.restic_repository, "BACKUP_PATHS": "/persistent-data", "CRON_FREQUENCY": "0 0 * * *", # every 1 day } self.workload_ids.append( deployer.deploy_container( pool_id=self.pool_id, node_id=self.selected_node.node_id, network_name=self.network_view.name, ip_address=self.ip_address, flist=self.FLIST_URL, cpu=self.resources["cru"], memory=self.resources["mru"] * 1024, disk_size=self.resources["sru"] * 1024, volumes=volume_config, env=var_dict, secret_env=secret_env, interactive=False, entrypoint="/start.sh", solution_uuid=self.solution_id, **self.solution_metadata, )) self.resv_id = self.workload_ids[-1] success = deployer.wait_workload(self.workload_ids[-1], self) if not success: raise DeploymentFailed( f"Failed to create container on node {self.selected_node.node_id} {self.workload_ids[-1]}. The resources you paid for will be re-used in your upcoming deployments.", solution_uuid=self.solution_id, wid=self.workload_ids[-1], ) # expose solution on nginx container _id = deployer.expose_and_create_certificate( pool_id=self.pool_id, gateway_id=self.gateway.node_id, network_name=self.network_view.name, trc_secret=self.secret, domain=self.domain, email=self.user_email, solution_ip=self.ip_address, solution_port=3000, enforce_https=False, proxy_pool_id=self.gateway_pool.pool_id, node_id=self.selected_node.node_id, solution_uuid=self.solution_id, log_config=self.nginx_log_config, **self.solution_metadata, ) success = deployer.wait_workload(_id, self) if not success: raise DeploymentFailed( f"Failed to create TRC container on node {self.selected_node.node_id}" f" {_id}. The resources you paid for will be re-used in your upcoming deployments.", solution_uuid=self.solution_id, wid=self.workload_ids[-1], )
def reservation(self): metadata = { "name": self.solution_name, "form_info": { "chatflow": self.SOLUTION_TYPE, "Solution name": self.solution_name }, } self.solution_metadata.update(metadata) self.workload_ids = [] # reserve subdomain subdomain_wid = deployer.create_subdomain( pool_id=self.pool_id, gateway_id=self.gateway.node_id, subdomain=self.domain, addresses=self.addresses, solution_uuid=self.solution_id, **self.solution_metadata, ) subdomain_wid = deployer.wait_workload(subdomain_wid, self) if not subdomain_wid: raise DeploymentFailed( f"Failed to create subdomain {self.domain} on gateway {self.gateway.node_id} {subdomain_wid}. The resources you paid for will be re-used in your upcoming deployments." ) private_key = PrivateKey.generate().encode(Base64Encoder).decode() flask_secret = j.data.idgenerator.chars(10) var_dict = { "EMAIL_HOST_USER": self.EMAIL_HOST_USER, "EMAIL_HOST": self.EMAIL_HOST, "TAIGA_HOSTNAME": self.domain, "HTTP_PORT": "80", "THREEBOT_URL": "https://login.threefold.me", "OPEN_KYC_URL": "https://openkyc.live/verification/verify-sei", } self.resv_id = deployer.deploy_container( pool_id=self.pool_id, node_id=self.selected_node.node_id, network_name=self.network_view.name, ip_address=self.ip_address, flist=self.FLIST_URL, cpu=self.resources["cru"], memory=self.resources["mru"] * 1024, disk_size=self.resources["sru"] * 1024, env=var_dict, interactive=False, entrypoint="/start_taiga.sh", public_ipv6=True, secret_env={ "EMAIL_HOST_PASSWORD": self.EMAIL_HOST_PASSWORD, "PRIVATE_KEY": private_key, "SECRET_KEY": self.SECRET_KEY, "FLASK_SECRET_KEY": flask_secret, }, **self.solution_metadata, solution_uuid=self.solution_id, ) success = deployer.wait_workload(self.resv_id, self) if not success: raise DeploymentFailed( f"Failed to deploy workload {self.resv_id}. The resources you paid for will be re-used in your upcoming deployments.", solution_uuid=self.solution_id, wid=self.resv_id, ) # expose taiga container _id = deployer.expose_and_create_certificate( pool_id=self.pool_id, gateway_id=self.gateway.node_id, network_name=self.network_view.name, trc_secret=self.secret, domain=self.domain, email=self.user_email, solution_ip=self.ip_address, solution_port=80, enforce_https=True, node_id=self.selected_node.node_id, solution_uuid=self.solution_id, proxy_pool_id=self.gateway_pool.pool_id, **self.solution_metadata, ) success = deployer.wait_workload(_id, self) if not success: raise DeploymentFailed( f"Failed to create TRC container on node {self.selected_node.node_id} {_id}. The resources you paid for will be re-used in your upcoming deployments.", solution_uuid=self.solution_id, wid=_id, )
def redeploy_threebot_solution( owner, solution_uuid, backup_password, compute_pool_id=None, gateway_pool_id=None, solution_info=None, node_id=None, bot=None, retry=False, prompt_retry_only=True, ): """ Args: owner (str): threebot_name of the logged in user solution_uuid (str): of the not-running threebot that needs to be started compute_pool_id (str): to override the pool id used for container deployment. if not specified, it will use the old pool id gateway_pool_id (str): to override the pool id used for subdomain and proxy deployment. if not specified, it will use the old pool id. (should override the subdomain specified in solution_info) solution_info (dict): to override the information used in deployment. if any key is not specified, it will use the old value """ if prompt_retry_only: msg_bot = None else: msg_bot = bot retries = 3 if retry else 1 solution_info = solution_info or {} owner = text.removesuffix(owner, ".3bot") j.logger.debug(f"Fetching solution info for uuid {solution_uuid} and owner {owner}") while retries: try: if bot: bot.md_show_update("Starting your 3Bot...") threebot = get_threebot_config_instance(owner, solution_uuid) if not threebot.verify_secret(backup_password): raise j.exceptions.Validation(f"incorrect secret provided") zos = get_threebot_zos(threebot) identity = generate_user_identity(threebot, backup_password, zos) with threebot_identity_context(identity.instance_name): j.logger.debug(f"Using identity {identity.instance_name}") with deployment_context(): zos = j.sals.zos.get(identity.instance_name) solution_workloads = get_threebot_workloads_by_uuid(solution_uuid, identity.instance_name) new_solution_info = build_solution_info(solution_workloads, threebot) j.logger.debug(f"old solution info: {new_solution_info}") new_solution_info.update(solution_info) j.logger.debug(f"updated solution info: {new_solution_info}") gateway_pool_id = gateway_pool_id or new_solution_info["gateway_pool"] compute_pool_id = compute_pool_id or new_solution_info["compute_pool"] # deploy using the new information with a new uuid. a new uuid to not conflict with the old one when listing solution_name = new_solution_info["name"] backup_model = BACKUP_MODEL_FACTORY.get(f"{solution_name}_{owner}") new_solution_uuid = uuid.uuid4().hex metadata = { "form_info": {"Solution name": solution_name, "chatflow": "threebot"}, "owner": f"{owner}.3bot", } # select node and update network j.logger.debug(f"fetching network {new_solution_info['network']}") network_view = deployer.get_network_view( new_solution_info["network"], identity_name=identity.instance_name ) j.logger.debug(f"searching for available node within pool {compute_pool_id}") if node_id: selected_node = zos._explorer.nodes.get(node_id) else: selected_node = deployer.schedule_container( pool_id=compute_pool_id, cru=new_solution_info["cpu"] + 1, mru=(new_solution_info["memory"] / 1024) + 1, sru=(new_solution_info["disk_size"] / 1024) + 0.25, ip_version="IPv6", ) j.logger.debug(f"found node with enough capacity {selected_node.node_id}") j.logger.debug(f"adding node {selected_node.node_id} to network {network_view.name}") result = deployer.add_network_node( network_view.name, selected_node, compute_pool_id, network_view, bot=msg_bot, identity_name=identity.instance_name, ) if result: for wid in result["ids"]: success = deployer.wait_workload( wid, msg_bot, breaking_node_id=selected_node.node_id, identity_name=identity.instance_name, ) if not success: raise DeploymentFailed( f"Failed to add node {selected_node.node_id} to network {wid}", wid=wid ) j.logger.debug(f"node {selected_node.node_id} added to network {network_view.name} successfuly") j.logger.debug("searching for a free ip address") network_view = network_view.copy() ip_address = network_view.get_free_ip(selected_node) j.logger.debug(f"found a free ip address {ip_address}") workload_ids = [] j.logger.debug(f"fetching gateway {new_solution_info['gateway']}") gateway = zos._explorer.gateway.get(new_solution_info["gateway"]) addresses = [] j.logger.debug(f"resolving gateway {gateway.node_id} name servers") for ns in gateway.dns_nameserver: try: addresses.append(j.sals.nettools.get_host_by_name(ns)) except: j.logger.error(f"failed to resolve name server {ns} of gateway {gateway.node_id}") if not addresses: raise StopChatFlow( f"the gateway specfied {gateway.node_id} doesn't have any valid name servers" ) domain = new_solution_info["domain"] j.logger.debug(f"deploying domain {domain} pointing to addresses {addresses}") workload_ids.append( deployer.create_subdomain( pool_id=gateway_pool_id, gateway_id=gateway.node_id, subdomain=domain, addresses=addresses, solution_uuid=new_solution_uuid, identity_name=identity.instance_name, **metadata, ) ) j.logger.debug(f"waiting for domain workload {workload_ids[-1]} to deploy") success = deployer.wait_workload( workload_ids[-1], bot=msg_bot, identity_name=identity.instance_name ) if not success: raise DeploymentFailed( f"Failed to create subdomain {domain} on gateway {gateway.node_id} {workload_ids[-1]}. The resources you paid for will be re-used in your upcoming deployments.", wid=workload_ids[-1], identity_name=identity.instance_name, ) test_cert = j.config.get("TEST_CERT") j.logger.debug("creating backup token") backup_token = str(j.data.idgenerator.idgenerator.uuid.uuid4()) backup_model.token = backup_token backup_model.tname = metadata["owner"] backup_model.save() j.logger.debug(f"backup token {backup_token} created for tname {backup_model.tname}") environment_vars = { "SDK_VERSION": new_solution_info["branch"], "INSTANCE_NAME": new_solution_info["name"], "THREEBOT_NAME": owner, "DOMAIN": domain, "SSHKEY": new_solution_info["public_key"], "TEST_CERT": "true" if test_cert else "false", "MARKETPLACE_URL": f"https://{j.sals.nginx.main.websites.threebot_deployer_threebot_deployer_root_proxy_443.domain}/", "DEFAULT_IDENTITY": "test" if "test" in j.core.identity.me.explorer_url else "main", } j.logger.debug(f"deploying threebot container with environment {environment_vars}") log_config = j.core.config.get("LOGGING_SINK", {}) if log_config: log_config["channel_name"] = f'{owner}-{new_solution_info["name"]}'.lower() workload_ids.append( deployer.deploy_container( pool_id=compute_pool_id, node_id=selected_node.node_id, network_name=network_view.name, ip_address=ip_address, flist=new_solution_info["flist"], env=environment_vars, cpu=new_solution_info["cpu"], memory=new_solution_info["memory"], disk_size=new_solution_info["disk_size"], secret_env={"BACKUP_PASSWORD": backup_password, "BACKUP_TOKEN": backup_token}, interactive=False, log_config=log_config, solution_uuid=new_solution_uuid, identity_name=identity.instance_name, **metadata, ) ) j.logger.debug(f"wating for threebot container workload {workload_ids[-1]} to be deployed") success = deployer.wait_workload( workload_ids[-1], bot=msg_bot, identity_name=identity.instance_name ) if not success: raise DeploymentFailed( f"Failed to create container on node {selected_node.node_id} {workload_ids[-1]}. The resources you paid for will be re-used in your upcoming deployments.", solution_uuid=new_solution_uuid, wid=workload_ids[-1], identity_name=identity.instance_name, ) j.logger.debug(f"threebot container workload {workload_ids[-1]} deployed successfuly") trc_log_config = j.core.config.get("LOGGING_SINK", {}) if trc_log_config: trc_log_config["channel_name"] = f'{owner}-{new_solution_info["name"]}-trc'.lower() identity_tid = identity.tid secret = f"{identity_tid}:{uuid.uuid4().hex}" j.logger.debug(f"deploying trc container") workload_ids.extend( deployer.expose_address( pool_id=compute_pool_id, gateway_id=gateway.node_id, network_name=network_view.name, local_ip=ip_address, port=80, tls_port=443, trc_secret=secret, node_id=selected_node.node_id, reserve_proxy=True, domain_name=domain, proxy_pool_id=gateway_pool_id, solution_uuid=new_solution_uuid, log_config=trc_log_config, identity_name=identity.instance_name, **metadata, ) ) j.logger.debug(f"wating for trc container workload {workload_ids[-1]} to be deployed") success = deployer.wait_workload( workload_ids[-1], bot=msg_bot, identity_name=identity.instance_name ) if not success: raise DeploymentFailed( f"Failed to create TRC container on node {selected_node.node_id} {workload_ids[-1]}. The resources you paid for will be re-used in your upcoming deployments.", solution_uuid=new_solution_uuid, wid=workload_ids[-1], identity_name=identity.instance_name, ) j.logger.debug(f"trc container workload {workload_ids[-1]} deployed successfuly") j.logger.debug(f"fetching farm information of pool {compute_pool_id}") farm_id = deployer.get_pool_farm_id(compute_pool_id) farm = zos._explorer.farms.get(farm_id) j.logger.debug(f"saving new threebot local config with uuid {new_solution_uuid}") instance_name = f"threebot_{new_solution_uuid}" user_threebot = USER_THREEBOT_FACTORY.get(instance_name) user_threebot.solution_uuid = new_solution_uuid user_threebot.identity_tid = identity.tid user_threebot.name = solution_name user_threebot.owner_tname = threebot.owner_tname user_threebot.farm_name = farm.name user_threebot.state = ThreebotState.RUNNING user_threebot.continent = farm.location.continent user_threebot.explorer_url = identity.explorer_url user_threebot.subdomain_wid = workload_ids[-4] user_threebot.threebot_container_wid = workload_ids[-3] user_threebot.trc_container_wid = workload_ids[-2] user_threebot.reverse_proxy_wid = workload_ids[-1] user_threebot.save() j.logger.debug(f"threebot local config of uuid {new_solution_uuid} saved") j.logger.debug(f"deleting old threebot local config with uuid {solution_uuid}") USER_THREEBOT_FACTORY.delete(f"threebot_{solution_uuid}") j.logger.debug("deployment successful") return user_threebot except DeploymentFailed as e: retries -= 1 if retries > 0: j.logger.error(f"3Bot {solution_uuid} redeployment failed. retrying {retries}") if bot and e.wid: bot.md_show_update(f"Deployment Failed for wid {e.wid}. retrying {retries} ....")
def _deploy(self): # 1- add node to network metadata = { "form_info": { "Solution name": self.solution_name, "chatflow": "threebot" } } self.solution_metadata.update(metadata) self.workload_ids = [] deploying_message = f"""\ # Deploying your 3Bot...\n\n <br>It will usually take a few minutes to succeed. Please wait patiently.\n You will be automatically redirected to the next step once succeeded. """ self.md_show_update(dedent(deploying_message), md=True) # 2- reserve subdomain if not self.custom_domain: self.workload_ids.append( deployer.create_subdomain( pool_id=self.gateway_pool.pool_id, gateway_id=self.gateway.node_id, subdomain=self.domain, addresses=self.addresses, solution_uuid=self.solution_id, identity_name=self.identity_name, **self.solution_metadata, )) success = deployer.wait_workload(self.workload_ids[-1], identity_name=self.identity_name) if not success: raise DeploymentFailed( f"Failed to create subdomain {self.domain} on gateway {self.gateway.node_id} {self.workload_ids[-1]}. The resources you paid for will be re-used in your upcoming deployments.", wid=self.workload_ids[-1], identity_name=self.identity_name, ) test_cert = j.config.get("TEST_CERT") # Generate a one-time token to create a user for backup backup_token = str(j.data.idgenerator.idgenerator.uuid.uuid4()) self.backup_model.token = backup_token self.backup_model.tname = self.solution_metadata["owner"] self.backup_model.save() # 3- deploy threebot container environment_vars = { "SDK_VERSION": self.branch, "INSTANCE_NAME": self.solution_name, "THREEBOT_NAME": self.threebot_name, "DOMAIN": self.domain, "SSHKEY": self.public_key, "TEST_CERT": "true" if test_cert else "false", "MARKETPLACE_URL": f"https://{j.sals.nginx.main.websites.threebot_deployer_threebot_deployer_root_proxy_443.domain}/", "DEFAULT_IDENTITY": "test" if "test" in j.core.identity.me.explorer_url else "main", # email settings "EMAIL_HOST": self.email_host, "EMAIL_HOST_USER": self.email_host_user, "ESCALATION_MAIL": self.escalation_mail_address, } self.network_view = self.network_view.copy() ## Container logs log_config = j.core.config.get("LOGGING_SINK", {}) if log_config: log_config[ "channel_name"] = f"{self.threebot_name}-{self.SOLUTION_TYPE}-{self.solution_name}".lower( ) self.workload_ids.append( deployer.deploy_container( pool_id=self.pool_id, node_id=self.selected_node.node_id, network_name=self.network_view.name, ip_address=self.ip_address, flist=self.FLIST_URL[self.branch], env=environment_vars, cpu=self.container_resources["cru"], memory=self.container_resources["mru"] * 1024, disk_size=self.container_resources["sru"] * 1024, secret_env={ "BACKUP_PASSWORD": self.backup_password, "BACKUP_TOKEN": backup_token, "EMAIL_HOST_PASSWORD": self.email_host_password, }, interactive=False, log_config=log_config, solution_uuid=self.solution_id, identity_name=self.identity_name, **self.solution_metadata, )) success = deployer.wait_workload(self.workload_ids[-1], identity_name=self.identity_name) if not success: raise DeploymentFailed( f"Failed to create container on node {self.selected_node.node_id} {self.workload_ids[-1]}. The resources you paid for will be re-used in your upcoming deployments.", solution_uuid=self.solution_id, wid=self.workload_ids[-1], identity_name=self.identity_name, ) # 4- expose threebot container wid, proxy_id = deployer.expose_address( pool_id=self.pool_id, gateway_id=self.gateway.node_id, network_name=self.network_view.name, local_ip=self.ip_address, port=80, tls_port=443, trc_secret=self.secret, node_id=self.selected_node.node_id, reserve_proxy=True, domain_name=self.domain, proxy_pool_id=self.gateway_pool.pool_id, solution_uuid=self.solution_id, log_config=self.trc_log_config, identity_name=self.identity_name, **self.solution_metadata, ) self.workload_ids.append(wid) self.workload_ids.append(proxy_id) success = deployer.wait_workload(self.workload_ids[-1], identity_name=self.identity_name) if not success: raise DeploymentFailed( f"Failed to create TRC container on node {self.selected_node.node_id} {self.workload_ids[-1]}. The resources you paid for will be re-used in your upcoming deployments.", solution_uuid=self.solution_id, wid=self.workload_ids[-1], identity_name=self.identity_name, ) self.threebot_url = f"https://{self.domain}/admin" instance_name = f"threebot_{self.solution_id}" user_threebot = USER_THREEBOT_FACTORY.get(instance_name) user_threebot.solution_uuid = self.solution_id user_threebot.identity_tid = j.core.identity.get( self.identity_name).tid user_threebot.name = self.solution_name user_threebot.owner_tname = self.threebot_name user_threebot.farm_name = self.farm_name user_threebot.state = ThreebotState.RUNNING if hasattr(self, "continent"): user_threebot.continent = self.continent if not self.custom_domain: user_threebot.subdomain_wid = self.workload_ids[-4] user_threebot.threebot_container_wid = self.workload_ids[-3] user_threebot.trc_container_wid = self.workload_ids[-2] user_threebot.reverse_proxy_wid = self.workload_ids[-1] user_threebot.explorer_url = j.core.identity.get( self.identity_name).explorer_url user_threebot.hash_secret(self.backup_password) user_threebot.save()
def deploy(self): # 1- add node to network metadata = { "form_info": { "Solution name": self.solution_name, "chatflow": "threebot" } } self.solution_metadata.update(metadata) self.workload_ids = [] # 2- reserve subdomain self.workload_ids.append( deployer.create_subdomain( pool_id=self.gateway_pool.pool_id, gateway_id=self.gateway.node_id, subdomain=self.domain, addresses=self.addresses, solution_uuid=self.solution_id, **self.solution_metadata, )) deploying_message = f"""\ # Deploying your 3Bot...\n\n <br>It will usually take a few minutes to succeed. Please wait patiently.\n You will be automatically redirected to the next step once succeeded. """ self.md_show_update(dedent(deploying_message), md=True) success = deployer.wait_workload(self.workload_ids[0]) if not success: raise DeploymentFailed( f"Failed to create subdomain {self.domain} on gateway {self.gateway.node_id} {self.workload_ids[0]}. The resources you paid for will be re-used in your upcoming deployments." ) test_cert = j.config.get("TEST_CERT") # Generate a one-time token to create a user for backup backup_token = str(j.data.idgenerator.idgenerator.uuid.uuid4()) self.backup_model.token = backup_token self.backup_model.tname = self.solution_metadata["owner"] self.backup_model.save() # 3- deploy threebot container environment_vars = { "SDK_VERSION": self.branch, "INSTANCE_NAME": self.solution_name, "THREEBOT_NAME": self.threebot_name, "DOMAIN": self.domain, # "SSHKEY": self.public_key, "TEST_CERT": "true" if test_cert else "false", "MARKETPLACE_URL": f"https://{j.sals.nginx.main.websites.threebot_deployer_threebot_deployer_root_proxy_443.domain}/", } self.network_view = self.network_view.copy() ## Container logs log_config = j.core.config.get("LOGGING_SINK", {}) if log_config: log_config["channel_name"] = self.solution_name self.workload_ids.append( deployer.deploy_container( pool_id=self.pool_id, node_id=self.selected_node.node_id, network_name=self.network_view.name, ip_address=self.ip_address, flist=self.FLIST_URL, env=environment_vars, cpu=self.container_resources["cru"], memory=self.container_resources["mru"] * 1024, disk_size=self.container_resources["sru"] * 1024, secret_env={ "BACKUP_PASSWORD": self.backup_password, "BACKUP_TOKEN": backup_token }, interactive=False, log_config=log_config, solution_uuid=self.solution_id, **self.solution_metadata, )) success = deployer.wait_workload(self.workload_ids[1]) if not success: raise DeploymentFailed( f"Failed to create container on node {self.selected_node.node_id} {self.workload_ids[-1]}. The resources you paid for will be re-used in your upcoming deployments.", solution_uuid=self.solution_id, wid=self.workload_ids[-1], ) # 4- expose threebot container self.workload_ids.append( deployer.expose_address( pool_id=self.pool_id, gateway_id=self.gateway.node_id, network_name=self.network_view.name, local_ip=self.ip_address, port=80, tls_port=443, trc_secret=self.secret, node_id=self.selected_node.node_id, reserve_proxy=True, domain_name=self.domain, proxy_pool_id=self.gateway_pool.pool_id, solution_uuid=self.solution_id, **self.solution_metadata, )) success = deployer.wait_workload(self.workload_ids[2]) if not success: raise DeploymentFailed( f"Failed to create TRC container on node {self.selected_node.node_id} {self.workload_ids[2]}. The resources you paid for will be re-used in your upcoming deployments.", solution_uuid=self.solution_id, wid=self.workload_ids[-1], ) self.threebot_url = f"https://{self.domain}/admin"
def deploy(self): metadata = { "name": self.solution_name, "form_info": { "Solution name": self.solution_name, "chatflow": self.SOLUTION_TYPE }, } self.solution_metadata.update(metadata) self.workload_ids = [] self.network_view = self.network_view.copy() result = deployer.add_network_node( self.network_view.name, self.selected_node, self.pool_id, self.network_view, bot=self, owner=self.solution_metadata.get("owner"), ) if result: for wid in result["ids"]: success = deployer.wait_workload( wid, self, breaking_node_id=self.selected_node.node_id) if not success: raise DeploymentFailed( f"Failed to add node {self.selected_node.node_id} to network {wid}. The resources you paid for will be re-used in your upcoming deployments.", wid=wid, ) self.network_view_copy = self.network_view.copy() self.ip_address = self.network_view_copy.get_free_ip( self.selected_node) # 2- reserve subdomain self.workload_ids.append( deployer.create_subdomain( pool_id=self.gateway_pool.pool_id, gateway_id=self.gateway.node_id, subdomain=self.domain, addresses=self.addresses, solution_uuid=self.solution_id, **self.solution_metadata, )) success = deployer.wait_workload(self.workload_ids[0], self) if not success: raise DeploymentFailed( f"Failed to create subdomain {self.domain} on gateway {self.gateway.node_id} {self.workload_ids[0]}. The resources you paid for will be re-used in your upcoming deployments." ) # 3- reserve tcp proxy self.workload_ids.append( deployer.create_proxy( pool_id=self.gateway_pool.pool_id, gateway_id=self.gateway.node_id, domain_name=self.domain, trc_secret=self.secret, solution_uuid=self.solution_id, **self.solution_metadata, )) success = deployer.wait_workload(self.workload_ids[1], self) if not success: raise DeploymentFailed( f"Failed to create reverse proxy {self.domain} on gateway {self.gateway.node_id} {self.workload_ids[-1]}. The resources you paid for will be re-used in your upcoming deployments.", solution_uuid=self.solution_id, wid=self.workload_ids[-1], ) # 4- deploy container self.envars[ "TRC_REMOTE"] = f"{self.gateway.dns_nameserver[0]}:{self.gateway.tcp_router_port}" self.envars["DOMAIN"] = self.domain self.envars["TEST_CERT"] = "true" if j.config.get( "TEST_CERT") else "false" secret_env = {"TRC_SECRET": self.secret} self.workload_ids.append( deployer.deploy_container( pool_id=self.pool_id, node_id=self.selected_node.node_id, network_name=self.network_view.name, ip_address=self.ip_address, flist=self.FLIST_URL, env=self.envars, cpu=self.query["cru"], memory=self.query["mru"] * 1024, disk_size=self.query["sru"] * 1024, entrypoint="/bin/bash /start.sh", secret_env=secret_env, interactive=False, solution_uuid=self.solution_id, public_ipv6=True, **self.solution_metadata, )) self.resv_id = self.workload_ids[-1] if not success: raise DeploymentFailed( f"Failed to create container on node {self.selected_node.node_id} {self.workload_ids[-1]}. The resources you paid for will be re-used in your upcoming deployments.", solution_uuid=self.solution_id, wid=self.workload_ids[-1], )
def _deploy(self): metadata = { "name": self.solution_name, "form_info": { "Solution name": self.solution_name, "Domain name": self.domain, "chatflow": self.SOLUTION_TYPE, }, } self.solution_metadata.update(metadata) # reserve subdomain _id = deployer.create_subdomain( pool_id=self.gateway_pool.pool_id, gateway_id=self.gateway.node_id, subdomain=self.domain, addresses=self.addresses, solution_uuid=self.solution_id, **self.solution_metadata, ) success = deployer.wait_workload(_id, self) if not success: raise DeploymentFailed( f"Failed to create subdomain {self.domain} on gateway" f" {self.gateway.node_id} {_id}. The resources you paid for will be re-used in your upcoming deployments.", wid=_id, ) self.solution_url = f"https://{self.domain}" # Create container self.resv_id = deployer.deploy_container( pool_id=self.pool_id, node_id=self.selected_node.node_id, network_name=self.network_view.name, ip_address=self.ip_address, flist=self.FLIST_URL, cpu=self.resources["cru"], memory=self.resources["mru"] * 1024, disk_size=self.resources["sru"] * 1024, interactive=False, entrypoint="/entrypoint.sh", solution_uuid=self.solution_id, **self.solution_metadata, ) success = deployer.wait_workload(self.resv_id, self) if not success: raise DeploymentFailed( f"Failed to deploy workload {self.resv_id}. The resources you paid for will be re-used in your upcoming deployments.", solution_uuid=self.solution_id, wid=self.resv_id, ) # expose threebot container _id, _ = deployer.expose_and_create_certificate( pool_id=self.pool_id, gateway_id=self.gateway.node_id, network_name=self.network_view.name, trc_secret=self.secret, domain=self.domain, email=self.user_email, solution_ip=self.ip_address, solution_port=80, enforce_https=True, node_id=self.selected_node.node_id, proxy_pool_id=self.gateway_pool.pool_id, solution_uuid=self.solution_id, **self.solution_metadata, ) success = deployer.wait_workload(_id, self) if not success: raise DeploymentFailed( f"Failed to create TRC container on node {self.selected_node.node_id}" f" {_id}. The resources you paid for will be re-used in your upcoming deployments.", solution_uuid=self.solution_id, wid=_id, )