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