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