def test_create_with_list_field(self):
cl = self.factory.get("test_list")
# test saving
user = cl.users.get("auser")
emails = ["*****@*****.**"]
perm1 = Permission()
perm1.is_admin = True
permissions = [perm1]
user.emails = emails
user.permissions = permissions
user.save()
cl.save()
# reset-factory for now, need to always get from store
self.factory = StoredFactory(Client)
ret_cl = self.factory.get("test_list")
self.assertNotEqual(cl, ret_cl)
user = ret_cl.users.get("auser")
self.assertEqual(user.emails, emails)
self.assertEqual(user.emails, emails)
def accept():
user_factory = StoredFactory(UserEntry)
user_info = j.data.serializers.json.loads(get_user_info())
tname = user_info["username"]
explorer_url = j.core.identity.me.explorer.url
if "testnet" in explorer_url:
explorer_name = "testnet"
elif "devnet" in explorer_url:
explorer_name = "devnet"
elif "explorer.grid.tf" in explorer_url:
explorer_name = "mainnet"
else:
return HTTPResponse(
j.data.serializers.json.dumps({"error": f"explorer {explorer_url} is not supported"}),
status=500,
headers={"Content-Type": "application/json"},
)
user_entry = user_factory.get(f"{explorer_name}_{tname.replace('.3bot', '')}")
if user_entry.has_agreed:
return HTTPResponse(
j.data.serializers.json.dumps({"allowed": True}), status=200, headers={"Content-Type": "application/json"}
)
else:
user_entry.has_agreed = True
user_entry.explorer_url = explorer_url
user_entry.tname = tname
user_entry.save()
return HTTPResponse(
j.data.serializers.json.dumps({"allowed": True}), status=201, headers={"Content-Type": "application/json"}
)
def test_secret_field(self):
cl = self.factory.get("test_secret")
user = cl.users.get("user_with_password")
# do not set password and try to save
# should not fail
user.save()
# do not forget to save the client
cl.save()
# get a new factory and check password
self.factory = StoredFactory(Client)
cl = self.factory.get("test_secret")
user = cl.users.get("user_with_password")
self.assertIsNone(user.password)
# set password and save
user.password = "******"
user.save()
cl.save()
# get a new factory and check password again
self.factory = StoredFactory(Client)
cl = self.factory.get("test_secret")
user = cl.users.get("user_with_password")
self.assertEqual(user.password, "test124")
def unhide_pool(self, pool_id) -> bool:
pool_factory = StoredFactory(PoolConfig)
if f"pool_{pool_id}" in pool_factory.list_all():
local_config = pool_factory.get(f"pool_{pool_id}")
local_config.hidden = False
local_config.save()
return True
def list_user_pools(self, username):
pool_factory = StoredFactory(UserPool)
_, _, user_pools = pool_factory.find_many(owner=username)
all_pools = [p for p in j.sals.zos.pools.list() if p.node_ids]
user_pool_ids = [p.pool_id for p in user_pools]
result = [p for p in all_pools if p.pool_id in user_pool_ids]
return result
def create_pool(self, username, bot):
pool_info = super().create_pool(bot)
pool_factory = StoredFactory(UserPool)
user_pool = pool_factory.new(f"pool_{username.replace('.3bot', '')}_{pool_info.reservation_id}")
user_pool.owner = username
user_pool.pool_id = pool_info.reservation_id
user_pool.save()
return pool_info
def create_solution_pool(self, bot, username, farm_name, expiration, currency, **resources):
cu, su = self.calculate_capacity_units(**resources)
pool_info = j.sals.zos.pools.create(int(cu * expiration), int(su * expiration), farm_name, [currency])
pool_factory = StoredFactory(UserPool)
user_pool = pool_factory.new(f"pool_{username.replace('.3bot', '')}_{pool_info.reservation_id}")
user_pool.owner = username
user_pool.pool_id = pool_info.reservation_id
user_pool.save()
return pool_info
def list_pools(self, include_hidden) -> str:
def pool_farm_from_cache(cache_dict, pool):
for node_id in pool.node_ids:
if node_id in cache_dict:
return cache_dict[node_id]
def update_pool_farm_cache(cache_dict, pool, farm):
for node_id in pool.node_ids:
cache_dict[node_id] = farm
res = []
farm_names = {}
node_to_farm = {}
pool_factory = StoredFactory(PoolConfig)
workloads_dict = {
w.id: w
for w in j.sals.zos.get().workloads.list(j.core.identity.me.tid,
NextAction.DEPLOY)
}
for pool in j.sals.zos.get().pools.list():
if not pool.node_ids:
continue
hidden = False
name = ""
if f"pool_{pool.pool_id}" in pool_factory.list_all():
local_config = pool_factory.get(f"pool_{pool.pool_id}")
hidden = local_config.hidden
name = local_config.name
if not include_hidden and hidden:
continue
pool_dict = pool.to_dict()
pool_dict["name"] = name
pool_dict["hidden"] = hidden
pool_dict["explorer_url"] = j.core.identity.me.explorer_url
farm = pool_farm_from_cache(node_to_farm, pool)
if not farm:
farm_id = deployer.get_pool_farm_id(pool=pool)
if farm_id >= 0:
farm = farm_names.get(farm_id)
if not farm:
farm = deployer._explorer.farms.get(farm_id)
farm_names[farm_id] = farm
update_pool_farm_cache(node_to_farm, pool, farm)
if farm:
pool_dict["farm"] = farm.name
for i, wid in enumerate(pool_dict["active_workload_ids"]):
if wid in workloads_dict:
pool_dict["active_workload_ids"][
i] = f"{workloads_dict[wid].info.workload_type.name} - {wid}"
else:
# due to differnet next action. we'll just show the id
pool_dict["active_workload_ids"][i] = wid
res.append(pool_dict)
return j.data.serializers.json.dumps({"data": res})
def pool_success(self):
pool_id = self.pool_data.reservation_id
pool_factory = StoredFactory(PoolConfig)
p = pool_factory.new(f"pool_{pool_id}")
p.name = self.pool_name
p.pool_id = pool_id
p.save()
self.md_show(
f"Transaction Succeeded! You just created a new capacity pool. It may take few minutes to reflect."
)
def allowed():
user_factory = StoredFactory(UserEntry)
user_info = j.data.serializers.json.loads(get_user_info())
tname = user_info["username"]
instances = user_factory.list_all()
for name in instances:
user_entry = user_factory.get(name)
if user_entry.tname == tname and user_entry.has_agreed:
return j.data.serializers.json.dumps({"allowed": True})
return j.data.serializers.json.dumps({"allowed": False})
def rename_pool(self, pool_id, name) -> str:
pool_factory = StoredFactory(PoolConfig)
if f"pool_{pool_id}" in pool_factory.list_all():
local_config = pool_factory.get(f"pool_{pool_id}")
else:
local_config = pool_factory.new(f"pool_{pool_id}")
local_config.pool_id = pool_id
local_config.name = name
local_config.save()
return j.data.serializers.json.dumps(local_config.to_dict())
def rename_pool(self, pool_id, name) -> str:
if not name.isidentifier() or not name.islower():
raise j.exceptions.Value(
"The pool name must be a lowercase valid python identitifier (English letters, underscores, and numbers not starting with a number)."
)
pool_factory = StoredFactory(PoolConfig)
if f"pool_{pool_id}" in pool_factory.list_all():
local_config = pool_factory.get(f"pool_{pool_id}")
else:
local_config = pool_factory.new(f"pool_{pool_id}")
local_config.pool_id = pool_id
local_config.name = name
local_config.save()
return j.data.serializers.json.dumps(local_config.to_dict())
def export_module_as():
from jumpscale.core.base import StoredFactory
from .sshclient import SSHClient
return StoredFactory(SSHClient)
def export_module_as():
from jumpscale.core.base import StoredFactory
from .docker import DockerClient
return StoredFactory(DockerClient)
def export_module_as():
from jumpscale.core.base import StoredFactory
from .digitalocean import DigitalOcean
return StoredFactory(DigitalOcean)
def reserve_pool(self):
valid = False
pool_factory = StoredFactory(PoolConfig)
while not valid:
self.pool_name = self.string_ask(
"Please choose a name for your new capacity pool. This name will only be used by you to identify the pool for later usage and management.",
required=True,
is_identifier=True,
)
_, _, result = pool_factory.find_many(name=self.pool_name)
if list(result):
self.md_show(
"the name is already used. please choose a different one")
continue
valid = True
self.pool_data = deployer.create_pool(self)
def export_module_as():
from jumpscale.core.base import StoredFactory
from .git import GitClient
return StoredFactory(GitClient)
def export_module_as():
from jumpscale.core.base import StoredFactory
from .gedis import GedisClient
return StoredFactory(GedisClient)
def accept_terms_conditions(cls, type_):
if type_ == "marketplace":
explorer_url = j.core.identity.me.explorer.url
if "testnet" in explorer_url:
explorer_name = "testnet"
elif "devnet" in explorer_url:
explorer_name = "devnet"
elif "explorer.grid.tf" in explorer_url:
explorer_name = "mainnet"
cls.user_entry_name = f"{explorer_name}_{cls.tname.replace('.3bot', '')}"
cls.user_factory = StoredFactory(MarkerplaceUserEntry)
else:
cls.user_entry_name = f"{cls.tname.replace('.3bot', '')}"
cls.user_factory = StoredFactory(AdminUserEntry)
admin_user_entry = cls.user_factory.get(cls.user_entry_name)
admin_user_entry.has_agreed = True
admin_user_entry.tname = cls.tname
admin_user_entry.save()
def accept():
user_factory = StoredFactory(UserEntry)
user_info = j.data.serializers.json.loads(get_user_info())
tname = user_info["username"]
user_entry = user_factory.get(f"{tname.replace('.3bot', '')}")
if user_entry.has_agreed:
return HTTPResponse(j.data.serializers.json.dumps({"allowed": True}),
status=200,
headers={"Content-Type": "application/json"})
else:
user_entry.has_agreed = True
user_entry.tname = tname
user_entry.save()
return HTTPResponse(j.data.serializers.json.dumps({"allowed": True}),
status=201,
headers={"Content-Type": "application/json"})
def test_create_with_enum_field(self):
cl = self.factory.get("test_enum")
# test saving
user = cl.users.get("admin")
# default value, still
self.assertEqual(user.type, UserType.USER)
# now set and test if it's saved
user.type = UserType.ADMIN
user.save()
cl.save()
# reset-factory for now, need to always get from store
self.factory = StoredFactory(Client)
ret_cl = self.factory.get("test_enum")
self.assertNotEqual(cl, ret_cl)
user = ret_cl.users.get("admin")
self.assertEqual(user.type, UserType.ADMIN)
def cancel_solution(self, username, solution_wids, delete_pool=False):
valid = True
pool_id = None
for wid in solution_wids:
workload = j.sals.zos.workloads.get(wid)
if workload.info.workload_type == WorkloadType.Container:
pool_id = workload.info.pool_id
metadata_json = j.sals.reservation_chatflow.deployer.decrypt_metadata(workload.info.metadata)
metadata = j.data.serializers.json.loads(metadata_json)
if metadata.get("owner") != username:
valid = False
break
if valid:
if pool_id and delete_pool:
# deassociate the pool from user
pool_factory = StoredFactory(UserPool)
instance_name = f"pool_{username.replace('.3bot', '')}_{pool_id}"
pool_factory.delete(instance_name)
super().cancel_solution(solution_wids)
def _validate_user(self):
tname = self.user_info()["username"].lower()
user_factory = StoredFactory(UserEntry)
explorer_url = j.core.identity.me.explorer.url
if "testnet" in explorer_url:
explorer_name = "testnet"
elif "devnet" in explorer_url:
explorer_name = "devnet"
elif "explorer.grid.tf" in explorer_url:
explorer_name = "mainnet"
else:
raise StopChatFlow(f"Unsupported explorer {explorer_url}")
instance_name = f"{explorer_name}_{tname.replace('.3bot', '')}"
if instance_name in user_factory.list_all():
user_entry = user_factory.get(instance_name)
if not user_entry.has_agreed:
raise StopChatFlow(
f"You must accept terms and conditions before using this solution. please head towards the main page to read our terms"
)
else:
raise StopChatFlow(
f"You must accept terms and conditions before using this solution. please head towards the main page to read our terms"
)
def setUpClass(cls):
# Set auto login config to disable TF Connect login.
j.core.config.set("AUTO_LOGIN", True)
# Get environment variables to create identity.
cls.tname = os.environ.get("TNAME")
cls.email = os.environ.get("EMAIL")
cls.words = os.environ.get("WORDS")
cls.explorer_url = "https://explorer.testnet.grid.tf/api/v1"
if not all([cls.tname, cls.email, cls.words]):
raise Exception(
"Please add (TNAME, EMAIL, WORDS) of your 3bot identity as environment variables"
)
# Check if there is identity registered to set it back after the tests are finished.
cls.me = None
if j.core.identity.list_all() and hasattr(j.core.identity, "me"):
cls.me = j.core.identity.me
# Accept T&C for testing identity.
cls.user_entry_name = f"{cls.tname.replace('.3bot', '')}"
cls.user_factory = StoredFactory(UserEntry)
user_entry = cls.user_factory.get(cls.user_entry_name)
user_entry.has_agreed = True
user_entry.tname = cls.tname
user_entry.save()
# Configure test identity and start threebot server.
cls.identity_name = j.data.random_names.random_name()
identity = j.core.identity.new(cls.identity_name,
tname=cls.tname,
email=cls.email,
words=cls.words,
explorer_url=cls.explorer_url)
identity.register()
identity.set_default()
cls.server = j.servers.threebot.get("default")
cls.server.start()
from jumpscale.loader import j
class ConvertedAddress(Base):
stellaraddress = fields.String()
# pool = None
activation_pool = None
tft_issuing_pool = None
tfta_issuing_pool = None
db_pool = None
WALLET = None
CONVERTED_ADDRESS_MODEL = StoredFactory(ConvertedAddress)
CONVERTED_ADDRESS_MODEL.always_reload = True
def create_gevent_pools():
global activation_pool, tft_issuing_pool, tfta_issuing_pool, db_pool
activation_pool = gevent.pool.Pool(1)
tft_issuing_pool = gevent.pool.Pool(1)
tfta_issuing_pool = gevent.pool.Pool(1)
db_pool = gevent.pool.Pool(1)
def _activate_account(address):
get_wallet().activate_account(address, starting_balance="3.6")
def export_module_as():
from jumpscale.core.base import StoredFactory
from .restic import ResticRepo
return StoredFactory(ResticRepo)
from jumpscale.core.base import StoredFactory from .backup_tokens import BackupTokens from .user_solutions import UserThreebot BACKUP_MODEL_FACTORY = StoredFactory(BackupTokens) BACKUP_MODEL_FACTORY.always_reload = True USER_THREEBOT_FACTORY = StoredFactory(UserThreebot) USER_THREEBOT_FACTORY.always_reload = True
from jumpscale.core.base import StoredFactory from .sshclient import SSHClient export_module_as = StoredFactory(SSHClient)
def export_module_as():
from jumpscale.core.base import StoredFactory
from .redis import RedisServer
return StoredFactory(RedisServer)
from jumpscale.core.base import StoredFactory from .gdrive import GdriveClient export_module_as = StoredFactory(GdriveClient)
