def reservation(self): metadata = { "name": self.solution_name, "form_info": { "chatflow": "flist", "Solution name": self.solution_name, "env": self.env }, } self.solution_metadata.update(metadata) volume_config = {} if self.container_volume_attach: 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}", wid=vol_id) volume_config[self.vol_mount_point] = vol_id 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_link, cpu=self.resources["cpu"], memory=self.resources["memory"], disk_size=self.resources["disk_size"], env=self.env, interactive=self.interactive, entrypoint=self.entrypoint, log_config=self.log_config, volumes=volume_config, public_ipv6=self.public_ipv6, **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}", solution_uuid=self.solution_id, wid=self.resv_id)
def etcd_ip(self): 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: self.md_show_update("Deploying Network on Nodes....") 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}", wid=wid) self.network_view = self.network_view.copy() self.ip_addresses = [] self.etcd_clutser = "" for n in range(self.no_nodes.value): free_ips = self.network_view.get_node_free_ips(self.selected_node) ip = self.drop_down_choice( f"Please choose IP Address for ETCD Node {n+1}", free_ips, default=free_ips[0], required=True, ) self.network_view.used_ips.append(ip) self.ip_addresses.append(ip) self.etcd_clutser = self.etcd_clutser + f"etcd_{n+1}=http://{ip}:2380,"
def reservation(self): self.etcd_flist = "https://hub.grid.tf/essam.3bot/bitnami-etcd-latest.flist" metadata = { "name": self.solution_name, "form_info": { "chatflow": "etcd", "Solution name": self.solution_name }, } self.solution_metadata.update(metadata) self.resv_ids = deployer.deploy_etcd_containers( self.pool_id, self.selected_node.node_id, self.network_view.name, self.ip_addresses, self.etcd_clutser, self.etcd_flist, self.resources["cpu"], self.resources["memory"], self.resources["disk_size"], self.public_ipv6, **self.solution_metadata, solution_uuid=self.solution_id, ) for resv_id in self.resv_ids: success = deployer.wait_workload(resv_id, self) if not success: raise DeploymentFailed(f"Failed to deploy workload {resv_id}", solution_uuid=self.solution_id, wid=resv_id)
def _deploy_network(self): # get ip address self.ip_address = None while not self.ip_address: self._select_node() result = deployer.add_network_node( self.network_view.name, self.selected_node, self.pool_id, self.network_view, bot=self, identity_name=self.identity_name, owner=self.solution_metadata.get("owner"), ) if result: self.md_show_update("Deploying Network on Nodes....") 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 = self.network_view.copy() self.ip_address = self.network_view.get_free_ip(self.selected_node) return self.ip_address
def container_ip(self): self.network_view_copy = self.network_view.copy() result = deployer.add_network_node( self.network_view.name, self.selected_node, self.pool_id, self.network_view_copy, 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}", wid=wid) self.network_view_copy = self.network_view_copy.copy() free_ips = self.network_view_copy.get_node_free_ips(self.selected_node) self.ip_address = self.drop_down_choice( "Please choose IP Address for your solution", free_ips, default=free_ips[0], required=True)
def reservation(self): metadata = { "form_info": { "chatflow": "vmachine", "name": self.solution_name, "solution_uuid": self.solution_id }, } self.solution_metadata.update(metadata) self.reservation, self.public_ip = deployer.deploy_vmachine( node_id=self.selected_node.node_id, network_name=self.network_view.name, name="ubuntu-20.04", ip_address=self.ip_address, ssh_keys=self.ssh_keys, pool_id=self.pool_id, size=self.vm_size, enable_public_ip=self.enable_public_ip, **self.solution_metadata, ) success = deployer.wait_workload(self.reservation, self) if not success: raise DeploymentFailed( f"Failed to deploy workload {self.reservation}", solution_uuid=self.solution_id, wid=self.reservation, )
def network_reservation(self): if self.action == "Create": try: self.config = deployer.deploy_network( self.solution_name, self.access_node, self.ip_range, self.ipversion, self.pool, **self.solution_metadata, ) except Exception as e: raise StopChatFlow(f"Failed to register workload due to error {str(e)}") else: self.config = deployer.add_access( self.network_view.name, self.network_view, self.access_node.node_id, self.pool, self.ipversion == "IPv4", bot=self, **self.solution_metadata, ) for wid in self.config["ids"]: try: success = deployer.wait_workload(wid, self, breaking_node_id=self.access_node.node_id) except StopChatFlow as e: if self.action == "Create": solutions.cancel_solution(self.config["ids"]) raise e if not success: raise DeploymentFailed(f"Failed to deploy workload {wid}", wid=wid)
def reservation(self): container_flist = f"{self.HUB_URL}/3bot-{self.version}.flist" metadata = { "name": self.solution_name, "form_info": {"chatflow": "ubuntu", "Solution name": self.solution_name}, } self.solution_metadata.update(metadata) 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=container_flist, cpu=self.resources["cpu"], memory=self.resources["memory"], disk_size=self.resources["disk_size"], env={"pub_key": self.public_key}, interactive=False, entrypoint="/bin/bash /start.sh", log_config=self.log_config, public_ipv6=self.public_ipv6, **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}", wid=self.resv_id)
def zdb_reservation(self): self.password = uuid.uuid4().hex self.metadata = { "Solution Name": self.solution_name, "Solution Type": "minio", "zdb_password": self.password } self.solution_metadata.update(self.metadata) self.zdb_result = deployer.deploy_minio_zdb( pool_id=self.zdb_pool_ids[0], password=self.password, node_ids=[n.node_id for n in self.zdb_nodes], zdb_no=self.zdb_number, pool_ids=self.zdb_pool_ids, solution_uuid=self.solution_id, disk_size=self.zdb_disk_size, disk_type=self.zdb_disk_type, **self.solution_metadata, ) for resv_id in self.zdb_result: success = deployer.wait_workload(resv_id, self) if not success: raise DeploymentFailed( f"failed to deploy zdb workload {resv_id}", solution_uuid=self.solution_id, wid=resv_id)
def reservation(self): metadata = { "name": self.solution_name, "form_info": {"chatflow": "kubernetes", "Solution name": self.solution_name}, } self.solution_metadata.update(metadata) self.reservations = deployer.deploy_kubernetes_cluster( pool_id=self.selected_pool_ids[0], node_ids=[n.node_id for n in self.selected_nodes], network_name=self.network_view.name, cluster_secret=self.cluster_secret, ssh_keys=self.ssh_keys, size=self.cluster_size, ip_addresses=self.ip_addresses, slave_pool_ids=self.selected_pool_ids[1:], solution_uuid=self.solution_id, **self.solution_metadata, ) for resv in self.reservations: success = deployer.wait_workload(resv["reservation_id"], self) if not success: raise DeploymentFailed( f"Failed to deploy workload {resv['reservation_id']}", solution_uuid=self.solution_id, wid=resv["reservation_id"], )
def init_new_user_network(self, bot, username, pool_id, ip_version="IPv4", identity_name=None, network_name=None): network_name = network_name or f"{username}_apps" access_node = j.sals.reservation_chatflow.reservation_chatflow.get_nodes( 1, pool_ids=[pool_id], ip_version=ip_version )[0] identity_name = identity_name or j.core.identity.me.instance_name result = self.deploy_network( name=network_name, access_node=access_node, ip_range="10.100.0.0/16", ip_version="IPv4", pool_id=pool_id, identity_name=identity_name, owner=username, ) for wid in result["ids"]: try: success = self.wait_workload(wid, bot=bot) except StopChatFlow as e: for sol_wid in result["ids"]: j.sals.zos.get(identity_name).workloads.decomission(sol_wid) raise e if not success: for sol_wid in result["ids"]: j.sals.zos.get(identity_name).workloads.decomission(sol_wid) raise DeploymentFailed( f"Failed to deploy apps network in workload {wid}. The resources you paid for will be re-used in your upcoming deployments.", wid=wid, ) wgcfg = result["wg"] return wgcfg
def ip_selection(self): self.md_show_update("Deploying Network on Nodes....") result = deployer.add_multiple_network_nodes( self.network_view.name, [node.node_id for node in self.selected_nodes], self.selected_pool_ids, self.network_view, self, owner=self.solution_metadata.get("owner"), ) if result: for wid in result["ids"]: success = deployer.wait_workload(wid, self) if not success: workload = j.sals.zos.get().workloads.get(wid) raise DeploymentFailed(f"Failed to add node {workload.info.node_id} to network {wid}", wid=wid) self.network_view = self.network_view.copy() # get ip addresses self.ip_addresses = [] master_free_ips = self.network_view.get_node_free_ips(self.selected_nodes[0]) self.ip_addresses.append( self.drop_down_choice( "Please choose IP Address for Master node", master_free_ips, required=True, default=master_free_ips[0] ) ) self.network_view.used_ips.append(self.ip_addresses[0]) for i in range(1, len(self.selected_nodes)): free_ips = self.network_view.get_node_free_ips(self.selected_nodes[i]) self.ip_addresses.append( self.drop_down_choice( f"Please choose IP Address for Slave node {i}", free_ips, required=True, default=free_ips[0] ) ) self.network_view.used_ips.append(self.ip_addresses[i])
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 network_reservation(self): # create config first for wid in self.config["ids"]: try: success = deployer.wait_workload( wid, self, breaking_node_id=self.access_node.node_id) except StopChatFlow as e: solutions.cancel_solution(self.config["ids"]) raise e if not success: raise DeploymentFailed(f"Failed to deploy workload {wid}", wid=wid)
def select_pool(self): cloud_units = j.sals.marketplace.deployer.calculate_capacity_units( **self.query) # At least select pools lasts for 15 mins self.pool_id = deployer.select_pool(self, cu=cloud_units.cu * 60 * 15, su=cloud_units.su * 60 * 15, **self.query) if not self.pool_id: raise DeploymentFailed( f"Failed to find a node with the required resources CRU: {self.query.get('cru')}, MRU: {self.query.get('mru', 0)}, CRU: {self.query.get('cru', 0)}, SRU: {self.query.get('sru', 0)}, IPV4U: {self.query.get('ipv4u', 0)}" ) self.selected_nodes = list( j.sals.zos.get(self.solution_metadata.get( "owner")).nodes_finder.nodes_by_capacity( pool_id=self.pool_id, cru=self.query["cru"], mru=self.query["mru"], sru=self.query["sru"])) if not self.selected_nodes: raise DeploymentFailed( f"Failed to find a node with the required resources CRU: {self.query.get('cru', 0)}, MRU: {self.query.get('mru', 0)}, CRU: {self.query.get('cru', 0)}, SRU: {self.query.get('sru')}" )
def minio_reservation(self): zdb_configs = [] for zid in self.zdb_result: zdb_configs.append(deployer.get_zdb_url(zid, self.password)) metadata = { "name": self.solution_name, "form_info": { "chatflow": "minio", "Solution name": self.solution_name, "zdb_password": self.password }, } self.solution_metadata.update(metadata) if self.mode == "Master/Slave": metadata["form_info"]["Slave IP"] = self.ip_addresses[1] self.minio_result = deployer.deploy_minio_containers( pool_id=self.minio_pool_ids[0], network_name=self.network_view.name, minio_nodes=[n.node_id for n in self.minio_nodes], minio_ip_addresses=self.ip_addresses, zdb_configs=zdb_configs, ak=self.ak, sk=self.sk, ssh_key=self.public_ssh_key, cpu=self.minio_cont_resources["cpu"], memory=self.minio_cont_resources["memory"], data=self.data, parity=self.parity, disk_size=1, log_config=self.log_config, mode=self.mode, bot=self, pool_ids=self.minio_pool_ids, solution_uuid=self.solution_id, public_ipv6=self.public_ipv6, **self.solution_metadata, ) for resv_id in self.minio_result: success = deployer.wait_workload(resv_id, self) if not success: raise DeploymentFailed( f"Failed to deploy Minio container workload {resv_id}", solution_uuid=self.solution_id, wid=resv_id)
def zdb_reservation(self): self.password = uuid.uuid4().hex self.zdb_result = deployer.deploy_minio_zdb( pool_id=self.zdb_pool_ids[0], password=self.password, node_ids=[n.node_id for n in self.zdb_nodes], zdb_no=self.zdb_number, pool_ids=self.zdb_pool_ids, solution_uuid=self.solution_id, **self.solution_metadata, ) for resv_id in self.zdb_result: success = deployer.wait_workload(resv_id, self) if not success: raise DeploymentFailed( f"failed to deploy zdb workload {resv_id}", solution_uuid=self.solution_id, wid=resv_id)
def ip_selection(self): self.md_show_update("Deploying Network on Nodes....") for i in range(len(self.minio_nodes)): node = self.minio_nodes[i] pool_id = self.minio_pool_ids[i] result = deployer.add_network_node( self.network_view.name, node, pool_id, self.network_view, bot=self, owner=self.solution_metadata.get("owner"), ) if not result: continue for wid in result["ids"]: success = deployer.wait_workload(wid, bot=self, breaking_node_id=node.node_id) if not success: raise DeploymentFailed( f"Failed to add node {node.node_id} to network {wid}", wid=wid) self.network_view = self.network_view.copy() self.ip_addresses = [] free_ips = self.network_view.get_node_free_ips(self.minio_nodes[0]) self.ip_addresses.append( self.drop_down_choice( "Please choose IP Address for Primary container", free_ips, required=True, default=free_ips[0])) self.network_view.used_ips.append(self.ip_addresses[0]) if self.mode == "Master/Slave": free_ips = self.network_view.get_node_free_ips(self.minio_nodes[1]) self.ip_addresses.append( self.drop_down_choice( "Please choose IP Address for Secondary container", free_ips, required=True, default=free_ips[0])) self.network_view.used_ips.append(self.ip_addresses[1])
def reservation(self): metadata = { "name": self.domain, "form_info": { "Solution name": self.domain, "chatflow": "exposed" } } self.solution_metadata.update(metadata) query = {"mru": 1, "cru": 1, "sru": 1} self.selected_node = deployer.schedule_container(self.pool_id, **query) self.network_name = self.solution["Network"] result = deployer.add_network_node( self.network_name, self.selected_node, self.pool_id, 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 to network {wid}", wid=wid) self.network_view = deployer.get_network_view(self.network_name) self.tcprouter_ip = self.network_view.get_free_ip(self.selected_node) if not self.tcprouter_ip: raise StopChatFlow( f"No available ips one for network {self.network_view.name} node {self.selected_node.node_id}" ) if self.domain_type != "Custom Domain": self.dom_id = deployer.create_subdomain( pool_id=self.domain_pool.pool_id, gateway_id=self.domain_gateway.node_id, subdomain=self.domain, **self.solution_metadata, solution_uuid=self.solution_id, ) success = deployer.wait_workload(self.dom_id, self) if not success: raise DeploymentFailed( f"Failed to reserve sub-domain workload {self.dom_id}", solution_uuid=self.solution_id) if self.proxy_type == "TRC": self.proxy_id = deployer.create_proxy( pool_id=self.domain_pool.pool_id, gateway_id=self.domain_gateway.node_id, domain_name=self.domain, trc_secret=self.secret, **self.solution_metadata, solution_uuid=self.solution_id, ) success = deployer.wait_workload(self.proxy_id, self) if not success: raise DeploymentFailed( f"Failed to reserve reverse proxy workload {self.proxy_id}", solution_uuid=self.solution_id) trc_log_config = j.core.config.get("LOGGING_SINK", {}) if trc_log_config: trc_log_config[ "channel_name"] = f"{self.threebot_name}-{self.solution_name}-trc".lower( ) if self.proxy_type == "NGINX": self.tcprouter_id = deployer.expose_and_create_certificate( domain=self.domain, email=self.email, pool_id=self.pool_id, gateway_id=self.domain_gateway.node_id, network_name=self.network_name, solution_ip=self.solution_ip, solution_port=self.port, trc_secret=self.secret, bot=self, enforce_https=self.force_https, log_config=trc_log_config, **self.solution_metadata, solution_uuid=self.solution_id, ) else: self.tcprouter_id, _ = deployer.expose_address( pool_id=self.pool_id, gateway_id=self.domain_gateway.node_id, network_name=self.network_name, local_ip=self.solution_ip, port=self.port, tls_port=self.tls_port, trc_secret=self.secret, bot=self, log_config=trc_log_config, **self.solution_metadata, solution_uuid=self.solution_id, ) success = deployer.wait_workload(self.tcprouter_id, self) if not success: raise DeploymentFailed( f"Failed to reserve TCP Router container workload {self.tcprouter_id}", solution_uuid=self.solution_id, wid=self.tcprouter_id, )
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 _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": "monitoring", "Solution name": self.solution_name, }, } self.solution_metadata.update(metadata) self.md_show_update("Deploying Volume....") vol_id = deployer.deploy_volume( self.selected_pool_ids[1], self.selected_nodes[1].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_nodes[1].node_id} {vol_id}", wid=vol_id) volume_configs = [{}, {self.vol_mount_point: vol_id}, {}] log_configs = [ {}, { "channel_type": "redis", "channel_host": self.ip_addresses[0], "channel_port": 6379, "channel_name": "prometheus", }, { "channel_type": "redis", "channel_host": self.ip_addresses[0], "channel_port": 6379, "channel_name": "grafana", }, ] self.reservation_ids = [] for i in range(3): self.md_show_update(f"Deploying {self.tools_names[i]}....") flist = self.flists[i] node = self.selected_nodes[i] pool_id = self.selected_pool_ids[i] volume_config = volume_configs[i] log_config = log_configs[i] ip_address = self.ip_addresses[i] self.reservation_ids.append( deployer.deploy_container( pool_id=pool_id, node_id=node.node_id, network_name=self.network_view.name, ip_address=ip_address, flist=flist, cpu=self.query[self.tools_names[i]]["cpu"], memory=self.query[self.tools_names[i]]["memory"], disk_size=self.query[self.tools_names[i]]["disk_size"], env=self.env_var_dict, interactive=False, entrypoint="", volumes=volume_config, log_config=log_config, **self.solution_metadata, solution_uuid=self.solution_id, )) success = deployer.wait_workload(self.reservation_ids[i], self) if not success: raise DeploymentFailed( f"Failed to deploy {self.tools_names[i]}", solution_uuid=self.solution_id, wid=self.reservation_ids[i], )
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 reservation(self): metadata = { "name": self.domain, "form_info": { "Solution name": self.domain, "chatflow": "exposed" } } self.solution_metadata.update(metadata) query = {"mru": 1, "cru": 1, "sru": 1} self.selected_node = deployer.schedule_container(self.pool_id, **query) self.network_name = self.solution["Network"] result = deployer.add_network_node( self.network_name, self.selected_node, self.pool_id, 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 to network {wid}", wid=wid) self.network_view = deployer.get_network_view(self.network_name) self.tcprouter_ip = self.network_view.get_free_ip(self.selected_node) if not self.tcprouter_ip: raise StopChatFlow( f"No available ips one for network {self.network_view.name} node {self.selected_node.node_id}" ) if self.domain_type != "Custom Domain": self.dom_id = deployer.create_subdomain( pool_id=self.domain_pool.pool_id, gateway_id=self.domain_gateway.node_id, subdomain=self.domain, **self.solution_metadata, solution_uuid=self.solution_id, ) success = deployer.wait_workload(self.dom_id, self) if not success: raise DeploymentFailed( f"Failed to reserve sub-domain workload {self.dom_id}", solution_uuid=self.solution_id) self.proxy_id = deployer.create_proxy( pool_id=self.domain_pool.pool_id, gateway_id=self.domain_gateway.node_id, domain_name=self.domain, trc_secret=self.secret, **self.solution_metadata, solution_uuid=self.solution_id, ) success = deployer.wait_workload(self.proxy_id, self) if not success: raise DeploymentFailed( f"Failed to reserve reverse proxy workload {self.proxy_id}", solution_uuid=self.solution_id) self.tcprouter_id = deployer.expose_address( pool_id=self.pool_id, gateway_id=self.domain_gateway.node_id, network_name=self.network_name, local_ip=self.solution_ip, port=self.port, tls_port=self.tls_port, trc_secret=self.secret, bot=self, **self.solution_metadata, solution_uuid=self.solution_id, ) success = deployer.wait_workload(self.tcprouter_id, self) if not success: raise DeploymentFailed( f"Failed to reserve TCP Router container workload {self.tcprouter_id}", solution_uuid=self.solution_id, wid=self.tcprouter_id, )
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 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 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): 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, )