class TwilioSMSClient(Client): """Your Account Sid and Auth Token from twilio.com/console DANGER! This is insecure. See http://twil.io/secure """ account_sid = fields.String() auth_token = fields.String() def __init__(self): super().__init__() self.__client = None @property def twilio_rest_client(self): if not self.__client: self.__client = TwilioRestClient(self.account_sid, self.auth_token) return self.__client def send_sms(self, body, sender, recievers=None): """send sms Your Account Sid and Auth Token from twilio.com/console DANGER! This is insecure. See http://twil.io/secure Arguments: body (string) : the sms text sender (text) : sender full number ex: +15558675310 Keyword Arguments: recievers (list) : recievers phone numbers """ recievers = recievers or [] for r in recievers: message = self.twilio_rest_client.messages.create(body=body, from_=sender, to=r) print(message.sid)
class TfgridSolution1(Base): id = fields.Integer() name = fields.String(default="") solution_type = fields.Enum(SolutionType) rid = fields.Integer() form_info = fields.Typed(dict) explorer = fields.String(default="")
class Website(Base): port = fields.Integer(default=80) ssl = fields.Boolean() domain = fields.String() path = fields.String() locations = fields.Factory(Location) @property def path_cfg_dir(self): return f"{self.parent.path_cfg_dir}/servers" @property def path_cfg(self): return f"{self.path_cfg_dir}/{self.instance_name}.http.conf" @property def path_web(self): return self.parent.path_web def configure(self): """Writes configuration of the website and its locations """ j.sals.fs.mkdir(self.path_cfg_dir) config = render_config_template("website", base_dir=j.core.dirs.BASEDIR, website=self) j.sals.fs.write_file(self.path_cfg, config) for location_name in self.locations.list_all(): location = self.locations.get(location_name) location.configure()
class PoolCreate(Base): json = fields.String() data_reservation = fields.Object(PoolCreateData) customer_tid = fields.Integer() customer_signature = fields.String() sponsor_tid = fields.Integer() sponsor_signature = fields.String()
class PoolCreateData(Base): pool_id = fields.Integer() cus = fields.Integer() sus = fields.Integer() ipv4us = fields.Integer() node_ids = fields.List(fields.String()) currencies = fields.List(fields.String())
class S3ZDB(VDCHostBase): size = fields.Integer() port = fields.Integer() namespace = fields.String() proxy_address = fields.String() @classmethod def from_workload(cls, workload): result_json = j.data.serializers.json.loads(workload.info.result.data_json) if not result_json: j.logger.warning(f"Couldn't get result details for zdb workload: {workload.id}") return if "IPs" in result_json: ip = result_json["IPs"][0] else: ip = result_json["IP"] namespace = result_json["Namespace"] port = result_json["Port"] zdb = cls() zdb.node_id = workload.info.node_id zdb.pool_id = workload.info.pool_id zdb.wid = workload.id zdb.size = workload.size zdb.ip_address = ip zdb.port = port zdb.namespace = namespace return zdb
class TrelloClient(Client): name = fields.String() api_key_ = fields.String() secret = fields.String() access_token = fields.String() acess_token_secret = fields.String() def __init__(self): super().__init__() self.__client = None @property def trello_client(self): if not self.token_secret: # print("**WILL TRY TO DO OAUTH SESSION") access_token = create_oauth_token(key=self.api_key, secret=self.secret) self.access_token_ = access_token["oauth_token"] self.access_token_secret = access_token["oauth_token_secret"] self.client = TrelloAPIClient(api_key=self.api_key_, api_secret=self.secret, token=self.token, token_secret=self.token_secret)
class GatewayProxy(Base): id = fields.Integer() domain = fields.String(default="") addr = fields.String(default="") port = fields.Integer() port_tls = fields.Integer() info = fields.Object(ReservationInfo)
class Explorer(Client): url = fields.String() identity_name = fields.String() def __init__(self, url=None, identity_name=None, **kwargs): super().__init__(url=url, identity_name=identity_name, **kwargs) if identity_name: self._loaded_identity = identity.export_module_as().get( identity_name) else: self._loaded_identity = identity.get_identity() self._session = requests.Session() self._session.hooks = dict(response=raise_for_status) secret = self._loaded_identity.nacl.signing_key.encode(Base64Encoder) auth = HTTPSignatureAuth( key_id=str(self._loaded_identity.tid), secret=secret, headers=["(created)", "date", "threebot-id"], ) headers = {"threebot-id": str(self._loaded_identity.tid)} self._session.auth = auth self._session.headers.update(headers) self.nodes = Nodes(self) self.users = Users(self) self.farms = Farms(self) self.reservations = Reservations(self) self.gateway = Gateways(self) self.pools = Pools(self) self.workloads = Workloads(self) self.conversion = Conversion(self)
class VMachine(VDCWorkloadBase): name = fields.String() public_ip = fields.Object(PublicIP) size = fields.Integer() resources = fields.Typed(dict) ip_address = fields.String(default="") @classmethod def from_workload(cls, workload): vmachine = cls() vmachine.wid = workload.id metadata = j.sals.reservation_chatflow.reservation_chatflow.decrypt_reservation_metadata(workload.info.metadata) metadata = j.data.serializers.json.loads(metadata) vmachine.name = metadata["form_info"]["name"] vmachine.pool_id = workload.info.pool_id vmachine.node_id = workload.info.node_id vmachine.size = workload.size vmachine.resources = VMSIZES.get(workload.size) vmachine.ip_address = workload.ipaddress if workload.public_ip: vmachine.public_ip.wid = workload.public_ip zos = get_zos() public_ip_workload = zos.workloads.get(workload.public_ip) address = str(netaddr.IPNetwork(public_ip_workload.ipaddress).ip) vmachine.public_ip.address = address return vmachine
class VirtualMachine(Base): id = fields.Integer() name = fields.String(default="") hub_url = fields.String(default="") description = fields.String(default="") network_connection = fields.List(fields.Object(ContainerNetworkConnection)) network_id = fields.String() farmer_tid = fields.Integer() size = fields.Integer() info = fields.Object(ReservationInfo) ssh_keys = fields.List(fields.String()) public_ip = fields.Integer() ipaddress = fields.IPAddress() SIZES = VMSIZES def resource_units(self): resource_units = ResourceUnitAmount() size = VMSIZES.get(self.size) if not size: raise j.exceptions.Input(f"VM size {self.size} not supported") resource_units.cru += size["cru"] resource_units.mru += size["mru"] resource_units.sru += size["sru"] return resource_units
class HardwareProof(Base): created = fields.DateTime() hardware_hash = fields.String(default="") disk_hash = fields.String(default="") hardware = fields.Typed(dict) disks = fields.Typed(dict) hypervisor = fields.List(fields.String())
class Container(Base): id = fields.Integer() flist = fields.String(default="") hub_url = fields.String(default="") storage_url = fields.String(default="") environment = fields.Typed(dict) secret_environment = fields.Typed(dict) entrypoint = fields.String(default="") interactive = fields.Boolean(default=True) volumes = fields.List(fields.Object(ContainerMount)) network_connection = fields.List(fields.Object(ContainerNetworkConnection)) stats = fields.List(fields.Object(ContainerStats)) farmer_tid = fields.Integer() logs = fields.List(fields.Object(ContainerLogs)) capacity = fields.Object(ContainerCapacity) info = fields.Object(ReservationInfo) def resource_units(self): cap = self.capacity resource_units = ResourceUnitAmount() resource_units.cru = cap.cpu resource_units.mru = round(cap.memory / 1024 * 10000) / 10000 storage_size = round(cap.disk_size / 1024 * 10000) / 10000 storage_size = max(0, storage_size - 50) # we offer the 50 first GB of storage for container root filesystem if cap.disk_type == DiskType.HDD: resource_units.hru += storage_size elif cap.disk_type == DiskType.SSD: resource_units.sru += storage_size return resource_units
class User(Base): emails = fields.List(fields.String()) permissions = fields.List(fields.Object(Permission)) custom_config = fields.Typed(dict) type = fields.Enum(UserType) password = fields.Secret() first_name = fields.String(default="") last_name = fields.String(default="") def get_full_name(self): name = self.first_name if self.last_name: name += " " + self.last_name return name def get_unique_name(self): return self.full_name.replace(" ", "") + ".user" full_name = fields.String(compute=get_full_name) unique_name = fields.String(compute=get_unique_name) def get_my_greeter(self): return Greeter(self.full_name) my_greeter = fields.Typed(Greeter, stored=False, compute=get_my_greeter) ahmed_greeter = fields.Typed(Greeter, stored=False, default=Greeter("ahmed"))
class K8s(Base): id = fields.Integer() size = fields.Integer() network_id = fields.String(default="") ipaddress = fields.IPAddress() cluster_secret = fields.String(default="") master_ips = fields.List(fields.IPAddress()) ssh_keys = fields.List(fields.String()) public_ip = fields.Integer() stats_aggregator = fields.List(fields.Object(Statsaggregator)) info = fields.Object(ReservationInfo) datastore_endpoint = fields.String(default="") disable_default_ingress = fields.Boolean(default=True) SIZES = VMSIZES def resource_units(self): resource_units = ResourceUnitAmount() size = VMSIZES.get(self.size) if not size: raise j.exceptions.Input(f"kubernetes size {self.size} not supported") resource_units.cru += size["cru"] resource_units.mru += size["mru"] resource_units.sru += size["sru"] return resource_units
class SonicClient(Client): host = fields.String(default="127.0.0.1") port = fields.Integer(default=1491) password = fields.String(default="pass") def __init__(self): super().__init__() self.cached_client_search = None self.cached_client_ingest = None self.push = self.client_ingest.push self.pop = self.client_ingest.pop self.count = self.client_ingest.count self.flush = self.client_ingest.flush self.flush_collection = self.client_ingest.flush_collection self.flush_bucket = self.client_ingest.flush_bucket self.flush_object = self.client_ingest.flush_object self.query = self.client_search.query self.suggest = self.client_search.suggest @property def client_ingest(self): if not self.cached_client_ingest: self.cached_client_ingest = IngestClient(host=self.host, port=self.port, password=self.password) return self.cached_client_ingest @property def client_search(self): if not self.cached_client_search: self.cached_client_search = SearchClient(host=self.host, port=self.port, password=self.password) return self.cached_client_search
class ChartConfig(Base): cert_resolver = fields.String(default="le") domain = fields.String(default=None) domain_type = fields.String() resources_limits = fields.Typed(dict, default={}) backup = fields.String(default="vdc") ip_version = fields.String(default="IPv6") extra_config = fields.Typed(dict, default={})
class GatewaySubdomain(Base): id = fields.Integer() domain = fields.String(default="") ips = fields.List(fields.String()) info = fields.Object(ReservationInfo) def resource_units(self): return ResourceUnitAmount()
class GatewayReverseProxy(Base): id = fields.Integer() domain = fields.String(default="") secret = fields.String(default="") info = fields.Object(ReservationInfo) def resource_units(self): return ResourceUnitAmount()
class ReservationResult(Base): category = fields.Enum(Category) workload_id = fields.String(default="") data_json = fields.Json() signature = fields.Bytes() state = fields.Enum(State) message = fields.String(default="") epoch = fields.DateTime()
class ContainerLogsRedis(Base): # deprecated, please use secret_stdout instead stdout = fields.String(default="") # deprecated, please use secret_stderr instead stderr = fields.String(default="") secret_stdout = fields.String(default="") secret_stderr = fields.String(default="")
class Location(Base): city = fields.String(default="") country = fields.String(default="") continent = fields.String(default="") latitude = fields.Float() longitude = fields.Float() def __str__(self): return ",".join([x for x in [self.continent, self.country, self.city] if x])
class GatewayProxy(Base): id = fields.Integer() domain = fields.String(default="") addr = fields.String(default="") port = fields.Integer() port_tls = fields.Integer() info = fields.Object(ReservationInfo) def resource_units(self): return ResourceUnitAmount()
class K8s(Base): id = fields.Integer() size = fields.Integer() network_id = fields.String(default="") ipaddress = fields.IPAddress() cluster_secret = fields.String(default="") master_ips = fields.List(fields.IPAddress()) ssh_keys = fields.List(fields.String()) stats_aggregator = fields.List(fields.Object(Statsaggregator)) info = fields.Object(ReservationInfo)
class NetworkResource(Base): id = fields.Integer() name = fields.String(default="") network_iprange = fields.IPRange(default="10.10.0.0/16") wireguard_private_key_encrypted = fields.String(default="") wireguard_public_key = fields.String(default="") wireguard_listen_port = fields.Integer() iprange = fields.IPRange(default="10.10.10.0/24") peers = fields.List(fields.Object(WireguardPeer)) info = fields.Object(ReservationInfo)
class ZdbNamespace(Base): id = fields.Integer() node_id = fields.String(default="") size = fields.Integer() mode = fields.Enum(ZDBMode) password = fields.String(default="") disk_type = fields.Enum(DiskType) public = fields.Boolean(default=False) stats_aggregator = fields.List(fields.Object(Statsaggregator)) info = fields.Object(ReservationInfo)
class User(Base): user_code = fields.String(default="") poll_name = fields.String(default="") wallets_addresses = fields.List(fields.String()) transaction_hashes = fields.List(fields.String()) tokens = fields.Float(default=0.0) vote_data = fields.Typed(dict, default={}) extra_data = fields.Typed(dict, default={}) vote_data_weighted = fields.Typed(dict, default={}) has_voted = fields.Boolean(default=False) manifesto_version = fields.String(default="2.0.0")
class SSHKeyClient(Client): name = fields.String() public_key = fields.String() private_key = fields.String() #should use secret. private_key_path = fields.String() # should use secret. passphrase = fields.String(default="") # should use secret. duration = fields.Integer() allow_agent = fields.Boolean() def __init__(self): super().__init__() if self.private_key_path and j.sals.fs.exists(self.private_key_path): self.load_from_file_system() def load_from_file_system(self): self.public_key = j.sals.fs.read_file(self.public_key_path) self.private_key = j.sals.fs.read_file(self.private_key_path) def generate_keys(self): if not self.private_key_path: # TODO: make sure the new sshkey name doesn't exist. sshkeys_dir = j.sals.fs.join_paths(j.core.config.config_root, "sshkeys") j.sals.fs.mkdirs(sshkeys_dir) self.private_key_path = j.sals.fs.join_paths( sshkeys_dir, j.data.idgenerator.chars(8)) if self.passphrase and len(self.passphrase) < 5: raise ValueError( "invalid passphrase length: should be at least 5 chars.") cmd = 'ssh-keygen -f {} -N "{}"'.format(self.private_key_path, self.passphrase) rc, out, err = j.core.executors.run_local(cmd) if rc == 0: self.public_key = j.sals.fs.read_file(self.public_key_path) self.private_key = j.sals.fs.read_file(self.private_key_path) else: raise RuntimeError("couldn't create sshkey") @property def public_key_path(self): return "{}.pub".format(self.private_key_path) def write_to_filesystem(self): if not self.private_key: raise RuntimeError("no private key to write") if not self.public_key: raise RuntimeError("no public key to write") j.sals.fs.write_file(self.private_key_path, self.private_key) j.sals.fs.write_file(self.public_key_path, self.public_key) def delete_from_filesystem(self): pass
class PoolPayment(Base): id = fields.Integer() farmer_id = fields.Integer() address = fields.String() expiration = fields.DateTime() asset = fields.String() amount = fields.Integer() paid = fields.Boolean() released = fields.Boolean() canceled = fields.Boolean() cause = fields.String()
class Certbot(Base): DEFAULT_NAME = "certbot" DEFAULT_LOGS_DIR = j.sals.fs.join_paths(j.core.dirs.LOGDIR, DEFAULT_NAME) DEFAULT_CONFIG_DIR = j.sals.fs.join_paths(j.core.dirs.CFGDIR, DEFAULT_NAME) DEFAULT_WORK_DIR = j.sals.fs.join_paths(j.core.dirs.VARDIR, DEFAULT_NAME) # the following options match the certbot command arguments domain = fields.String(required=True) non_interactive = fields.Boolean(default=True) agree_tos = fields.Boolean(default=True) logs_dir = fields.String(default=DEFAULT_LOGS_DIR) config_dir = fields.String(default=DEFAULT_CONFIG_DIR) work_dir = fields.String(default=DEFAULT_WORK_DIR) email = fields.Email() server = fields.URL() eab_kid = fields.String() eab_hmac_key = fields.String() # for existing certificates key_path = fields.String() cert_path = fields.String() fullchain_path = fields.String() @property def run_cmd(self): args = [self.DEFAULT_NAME] for name, value in self.to_dict().items(): if name.endswith("_"): continue if value: # append only if the field has a value name = name.replace("_", "-") args.append(f"--{name}") # append the value itself only if it's a boolean value # boolean options are set by adding name only if not isinstance(value, bool): args.append(value) return args @property def install_cmd(self): # replace "certbot" with "certbot install" cmd = self.run_cmd cmd.insert(1, "install") return cmd @property def renew_cmd(self): # replace "certbot" with "certbot install" renew_certbot = Certbot(work_dir=self.work_dir, config_dir=self.config_dir, logs_dir=self.logs_dir, domain="") cmd = renew_certbot.run_cmd cmd.insert(1, "renew") return cmd