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,
)