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)