jaseci 1.4.2.5__py3-none-any.whl → 2.0.0__py3-none-any.whl

jaseci/extens/svc/prome_svc.py

@@ -1,378 +0,0 @@
-import time
-from prometheus_api_client import PrometheusConnect
-from jaseci.jsorc.jsorc import JsOrc
-
-
-class MetricValue:
-    node = None
-    pod = None
-
-    def __init__(self, _node: dict, _pod: dict):
-        self.node = _node
-        self.pod = _pod
-
-
-@JsOrc.service(name="prome", config="PROME_CONFIG", manifest="PROME_MANIFEST")
-class PrometheusService(JsOrc.CommonService):
-    ###################################################
-    #                     BUILDER                     #
-    ###################################################
-
-    def run(self):
-        self.app = PrometheusConnect(url=self.config.get("url"), disable_ssl=True)
-        self.ping()
-        self.cpu = Cpu(self.app)
-        self.memory = Memory(self.app)
-        self.network = Network(self.app)
-        self.disk = Disk(self.app)
-
-    ###################################################
-    #                  COMMON UTILS                   #
-    ###################################################
-
-    def ping(self) -> bool:
-        prom = self.app
-        response = prom._session.get(
-            "{0}/".format(prom.url),
-            verify=prom.ssl_verification,
-            headers=prom.headers,
-            timeout=2,
-        )
-        return response.ok
-
-    def all_metrics(self) -> list:
-        return self.app.all_metrics()
-
-    def pods(self, namespace: str = "", exclude_prom: bool = False) -> dict:
-        if namespace == "":
-            util = self.app.get_current_metric_value("kube_pod_info")
-        else:
-            util = self.app.get_current_metric_value(
-                f"kube_pod_info{{namespace='{namespace}'}}"
-            )
-        res = {}
-        for pod in util:
-            info = pod["metric"]
-            node = info["node"]
-            pod = info["pod"]
-            if exclude_prom and "prometheus" in pod:
-                continue
-            if res.get(node) is None:
-                res[node] = []
-            res[node].append(pod)
-        return res
-
-    def node_info(
-        self,
-        namespace: str = "",
-        exclude_prom: bool = False,
-        timestamp: int = 0,
-        duration: int = 0,
-    ) -> dict:
-        if namespace == "":
-            util = self.app.get_current_metric_value("kube_node_info")
-        else:
-            util = self.app.get_current_metric_value(
-                f"kube_node_info{{namespace='{namespace}'}}"
-            )
-
-        res = {}
-        disk_read = self.disk.read()
-        disk_write = self.disk.write()
-
-        node_names = [nodes["metric"]["node"] for nodes in util]
-
-        for node_name in node_names:
-            res[node_name] = {}
-
-        for node_name in node_names:
-            res[node_name]["disk_read_bytes"] = disk_read.get(node_name, 0)
-
-        for node_name in node_names:
-            res[node_name]["disk_write_bytes"] = disk_write.get(node_name, 0)
-
-        return res
-
-    def pod_info(
-        self,
-        namespace: str = "",
-        exclude_prom: bool = False,
-        timestamp: int = 0,
-        duration: int = 0,
-    ) -> dict:
-        if namespace == "":
-            util = self.app.get_current_metric_value("kube_pod_info")
-        else:
-            util = self.app.get_current_metric_value(
-                f"kube_pod_info{{namespace='{namespace}'}}"
-            )
-
-        res = {}
-
-        for pod in util:
-            pod_name = pod["metric"]["pod"]
-            if exclude_prom and "prometheus" in pod_name:
-                continue
-
-        for pod in util:
-            pod_name = pod["metric"]["pod"]
-            if exclude_prom and "prometheus" in pod_name:
-                continue
-            # res[pod_name] = pod["metric"]
-            res[pod_name] = {}
-
-        if timestamp != 0 and duration != 0:
-            cpu = self.cpu.utilization_per_pod_cores(ts=timestamp, duration=duration)
-        else:
-            cpu = self.cpu.utilization_per_pod_cores()
-        for pod in util:
-            pod_name = pod["metric"]["pod"]
-            if exclude_prom and "prometheus" in pod_name:
-                continue
-            pod_cpu = cpu.get(pod_name, 0)
-
-            res[pod_name]["cpu_utilization_cores"] = pod_cpu
-        if timestamp != 0 and duration != 0:
-            cpu = self.cpu.utilization_per_pod_cores(ts=timestamp, duration=duration)
-        else:
-            cpu = self.cpu.utilization_per_pod_cores()
-        for pod in util:
-            pod_name = pod["metric"]["pod"]
-            if exclude_prom and "prometheus" in pod_name:
-                continue
-            pod_cpu = cpu.get(pod_name, 0)
-
-            res[pod_name]["cpu_utilization_cores"] = pod_cpu
-
-        mem = self.memory.utilization_per_pod_bytes()
-        for pod in util:
-            pod_name = pod["metric"]["pod"]
-            pod_mem = mem.get(pod_name, 0)
-            res[pod_name]["mem_utilization_bytes"] = pod_mem
-
-        if timestamp != 0 and duration != 0:
-            recv = self.network.receive_per_pod_bytes(ts=timestamp, duration=duration)
-        else:
-            recv = self.network.receive_per_pod_bytes()
-        for pod in util:
-            pod_name = pod["metric"]["pod"]
-            if exclude_prom and "prometheus" in pod_name:
-                continue
-            pod_recv = recv.get(pod_name, 0)
-            res[pod_name]["network_recv_bytes"] = pod_recv
-
-        if timestamp != 0 and duration != 0:
-            tran = self.network.transmit_per_pod_bytes(ts=timestamp, duration=duration)
-        else:
-            tran = self.network.transmit_per_pod_bytes()
-        for pod in util:
-            pod_name = pod["metric"]["pod"]
-            if exclude_prom and "prometheus" in pod_name:
-                continue
-            pod_tran = tran.get(pod_name, 0)
-            res[pod_name]["network_tran_bytes"] = pod_tran
-
-        return res
-
-    def info(
-        self,
-        namespace: str = "",
-        exclude_prom: bool = False,
-        timestamp: int = 0,
-        duration: int = 0,
-    ) -> MetricValue:
-        node_value = self.node_info(
-            namespace=namespace,
-            exclude_prom=exclude_prom,
-            timestamp=timestamp,
-            duration=duration,
-        )
-        pod_value = self.pod_info(
-            namespace=namespace,
-            exclude_prom=exclude_prom,
-            timestamp=timestamp,
-            duration=duration,
-        )
-        return MetricValue(_node=node_value, _pod=pod_value)
-
-
-class Info:
-    def __init__(self, app):
-        self.app = app
-
-
-class Cpu(Info):
-    def utilization_core(self) -> dict:
-        util = self.app.get_current_metric_value(
-            'sum(irate(node_cpu_seconds_total{mode!="idle"}[10m])) by (node)'
-        )
-        res = {}
-        for node in util:
-            node_name = node["metric"]["node"]
-            node_util = float(node["value"][1])
-            res[node_name] = node_util
-        return res
-
-    def utilization_percentage(self) -> dict:
-        util = self.app.get_current_metric_value(
-            '(sum(irate(node_cpu_seconds_total{mode!="idle"}[10m])) by '
-            '(node)) / (sum(irate(node_cpu_seconds_total{mode!=""}[10m])) by '
-            "(node)) * 100"
-        )
-        res = {}
-        for node in util:
-            node_name = node["metric"]["node"]
-            node_util = float(node["value"][1])
-            res[node_name] = node_util
-        return res
-
-    def utilization_per_pod_cores(self, ts=int(time.time()), duration=10) -> dict:
-        query_str = f'sum(rate(container_cpu_usage_seconds_total{{pod!=""}}[{duration}s] @ {ts})) by (pod)'
-        util = self.app.get_current_metric_value(query_str)
-        res = {}
-        for pod in util:
-            pod_name = pod["metric"]["pod"]
-            value = float(pod["value"][1])
-            res[pod_name] = float(value)
-        return res
-
-
-class Memory(Info):
-    def total_bytes(self) -> dict:
-        util = self.app.get_current_metric_value(
-            "sum(node_memory_MemTotal_bytes) by (node)"
-        )
-        res = {}
-        for node in util:
-            node_name = node["metric"]["node"]
-            node_util = float(node["value"][1])
-            res[node_name] = node_util
-        return res
-
-    def utilization_bytes(self) -> dict:
-        util = self.app.get_current_metric_value(
-            "sum(node_memory_Active_bytes) by (node)"
-        )
-        res = {}
-        for node in util:
-            node_name = node["metric"]["node"]
-            node_util = float(node["value"][1])
-            res[node_name] = node_util
-        return res
-
-    def utilization_percentage(self) -> dict:
-        util = self.app.get_current_metric_value(
-            "sum(node_memory_Active_bytes / node_memory_MemTotal_bytes * 100 ) by "
-            "(node)"
-        )
-        res = {}
-        for node in util:
-            node_name = node["metric"]["node"]
-            node_util = float(node["value"][1])
-            res[node_name] = node_util
-        return res
-
-    def utilization_per_pod_bytes(self) -> dict:
-        util = self.app.get_current_metric_value(
-            'sum(container_memory_working_set_bytes{pod!=""}) by (pod)'
-        )
-        res = {}
-        for pod in util:
-            pod_name = pod["metric"]["pod"]
-            value = float(pod["value"][1])
-            res[pod_name] = float(value)
-        return res
-
-
-class Network(Info):
-    def receive_bytes(self) -> dict:
-        util = self.app.get_current_metric_value(
-            "sum (rate (node_network_receive_bytes_total{}[10m])) by (node)"
-        )
-        res = {}
-        for node in util:
-            node_name = node["metric"]["node"]
-            node_util = float(node["value"][1])
-            res[node_name] = node_util
-        return res
-
-    def receive_per_pod_bytes(self, ts: int = int(time.time()), duration: int = 10):
-        util = self.app.get_current_metric_value(
-            f'sum (rate (container_network_receive_bytes_total{{pod!=""}}[{duration}s] @ {ts})) by (pod)'
-        )
-        res = {}
-        for pod in util:
-            pod_name = pod["metric"]["pod"]
-            value = pod["value"][1]
-            res[pod_name] = float(value)
-        return res
-
-    def transmit_bytes(self) -> dict:
-        util = self.app.get_current_metric_value(
-            "sum (rate (node_network_transmit_bytes_total{}[10m])) by (node)"
-        )
-        res = {}
-        for node in util:
-            node_name = node["metric"]["node"]
-            node_util = float(node["value"][1])
-            res[node_name] = node_util
-        return res
-
-    def transmit_per_pod_bytes(self, ts: int = int(time.time()), duration: int = 10):
-        util = self.app.get_current_metric_value(
-            f'sum (rate (container_network_transmit_bytes_total{{pod!=""}}[{duration}s] @ {ts})) by (pod)'
-        )
-        res = {}
-        for pod in util:
-            pod_name = pod["metric"]["pod"]
-            value = pod["value"][1]
-            res[pod_name] = float(value)
-        return res
-
-
-class Disk(Info):
-    def total_bytes(self) -> dict:
-        util = self.app.get_current_metric_value(
-            'sum(avg (node_filesystem_size_bytes{mountpoint!="/boot", '
-            'fstype!="tmpfs"}) without (mountpoint)) by (node)'
-        )
-        res = {}
-        for node in util:
-            node_name = node["metric"]["node"]
-            node_util = float(node["value"][1])
-            res[node_name] = node_util
-        return res
-
-    def free_bytes(self) -> dict:
-        util = self.app.get_current_metric_value(
-            'sum(avg (node_filesystem_free_bytes{mountpoint!="/boot", '
-            'fstype!="tmpfs"}) without (mountpoint)) by (node)'
-        )
-        res = {}
-        for node in util:
-            node_name = node["metric"]["node"]
-            node_util = float(node["value"][1])
-            res[node_name] = node_util
-        return res
-
-    def read(self) -> dict:
-        util = self.app.get_current_metric_value(
-            "sum (rate (node_disk_read_bytes_total{}[10m])) by (node)"
-        )
-        res = {}
-        for node in util:
-            node_name = node["metric"]["node"]
-            node_util = float(node["value"][1])
-            res[node_name] = node_util
-        return res
-
-    def write(self) -> dict:
-        util = self.app.get_current_metric_value(
-            "sum (rate (node_disk_written_bytes_total{}[10m])) by (node)"
-        )
-        res = {}
-        for node in util:
-            node_name = node["metric"]["node"]
-            node_util = float(node["value"][1])
-            res[node_name] = node_util
-        return res

jaseci/extens/svc/redis_svc.py

@@ -1,63 +0,0 @@
-from jaseci.jsorc.jsorc import JsOrc
-from redis import Redis
-
-
-@JsOrc.service(
-    name="redis",
-    config="REDIS_CONFIG",
-    manifest="REDIS_MANIFEST",
-    priority=0,
-    proxy=True,
-)
-class RedisService(JsOrc.CommonService):
-    def run(self):
-        self.app = Redis(**self.config, decode_responses=True)
-        self.app.ping()
-
-    ###################################################
-    #                     COMMONS                     #
-    ###################################################
-
-    def get(self, name):
-        return self.app.get(name)
-
-    def set(self, name, val):
-        self.app.set(name, val)
-
-    def exists(self, name):
-        return self.app.exists(name)
-
-    def delete(self, name):
-        self.app.delete(name)
-
-    def hget(self, name, key):
-        return self.app.hget(name, key)
-
-    def hset(self, name, key, val):
-        self.app.hset(name, key, val)
-
-    def hexists(self, name, key):
-        return self.app.hexists(name, key)
-
-    def hdel(self, name, key):
-        self.app.hdel(name, key)
-
-    def hkeys(self, name):
-        return self.app.hkeys(name)
-
-    ###################################################
-    #                     CLEANER                     #
-    ###################################################
-
-    def clear(self, all=True):
-        if self.is_running():
-            if all:
-                self.app.flushall()
-            else:
-                self.app.flushdb()
-
-    # ---------------- PROXY EVENTS ----------------- #
-
-    def on_delete(self):
-        if self.is_running():
-            self.app.close()

jaseci/extens/svc/storage_svc.py

@@ -1,193 +0,0 @@
-from datetime import datetime, timedelta
-
-from jaseci.jsorc.jsorc import JsOrc
-from jaseci.utils.file_handler import FileHandler
-
-from libcloud.storage.types import Provider, ObjectDoesNotExistError
-from libcloud.storage.providers import get_driver as _get_driver
-from libcloud.storage.base import StorageDriver, Object, Container
-from libcloud.storage.drivers.azure_blobs import AzureBlobsStorageDriver
-
-from azure.storage.blob import generate_blob_sas
-
-
-@JsOrc.service(
-    name="store",
-    config="STORE_CONFIG",
-    manifest="STORE_MANIFEST",
-    priority=0,
-    proxy=True,
-)
-class StorageService(JsOrc.CommonService):
-    def run(self):
-        self.app = StorageHandler(self.config["providers"], self.config.get("default"))
-
-        # Testing
-        # obj = self.upload(FileHandler.fromPath("test.txt"))
-        # self.download(obj["name"])
-
-    def upload(
-        self, file: FileHandler, provider: str = None, container: str = None
-    ) -> dict:
-        provider = self.app.get_storage(provider)
-        buffer = file.open(mode="rb", encoding=None, detached=True)
-
-        metadata = {
-            "id": file.id,
-            "name": file.name,
-            "created": datetime.utcnow().isoformat(),
-        }
-
-        # metadata doesn't support empty value
-        if file.content_type:
-            metadata["content_type"] = file.content_type
-
-        # metadata doesn't support empty value
-        if file.field:
-            metadata["field"] = file.field
-
-        if container:
-            container = provider["driver"].get_container(container_name=container)
-
-        obj: Object = provider["driver"].upload_object_via_stream(
-            iterator=buffer,
-            container=container or provider["container"],
-            object_name=file.absolute_name,
-            extra={"meta_data": metadata},
-        )
-
-        buffer.close()
-
-        return obj.get_cdn_url()
-
-    def download(
-        self, file: str, provider: str = None, container: str = None
-    ) -> FileHandler:
-        provider = self.app.get_storage(provider)
-
-        obj: Object = provider["driver"].get_object(
-            container_name=container or provider["container"].name, object_name=file
-        )
-
-        temp_file = FileHandler(file)
-        temp_file.open(mode="wb", encoding=None)
-        for chunk in provider["driver"].download_object_as_stream(obj):
-            temp_file.write(chunk)
-        temp_file.close()
-
-        return temp_file
-
-    def cdn_url(
-        self, file: str, provider: str = None, container: str = None, **kwargs
-    ) -> str:
-        provider = self.app.get_storage(provider)
-        driver = provider["driver"]
-
-        return driver.get_object_cdn_url(
-            driver.get_object(
-                container_name=container or provider["container"].name, object_name=file
-            ),
-            **kwargs,
-        )
-
-    def delete(self, file: str, provider: str = None, container: str = None) -> bool:
-        provider = self.app.get_storage(provider)
-
-        try:
-            obj: Object = provider["driver"].get_object(
-                container_name=container or provider["container"].name, object_name=file
-            )
-        except ObjectDoesNotExistError:
-            return True
-
-        return provider["driver"].delete_object(obj)
-
-    def create_container(self, name: str, provider: str = None) -> Container:
-        provider = self.app.get_storage(provider)
-
-        return provider["driver"].create_container(container_name=name)
-
-    def has_container(self, name: str, provider: str = None) -> bool:
-        provider = self.app.get_storage(provider)
-
-        return isinstance(
-            provider["driver"].get_container(container_name=name), Container
-        )
-
-    def delete_container(self, name: str, provider: str = None) -> bool:
-        provider = self.app.get_storage(provider)
-
-        return provider["driver"].delete_container(
-            provider["driver"].get_container(container_name=name)
-        )
-
-
-class StorageHandler:
-    def __init__(self, providers: dict, default: str = None):
-        self.default = default
-        self.storage = {}
-
-        for key, value in providers.items():
-            try:
-                driver = get_driver(value["provider"])(**value["credentials"])
-                container = driver.get_container(container_name=value["container"])
-                self.storage[key] = {
-                    "source": value,
-                    "driver": driver,
-                    "container": container,
-                }
-                self.storage[key]
-            except Exception as e:
-                self.storage[key] = {"source": value, "error": str(e)}
-
-    def get_storage(self, provider: str = None) -> StorageDriver:
-        if provider:
-            return self.storage[provider]
-        elif self.default:
-            return self.storage[self.default]
-
-
-#############################################################################################
-# ----------------------------------- PROVIDER OVERRIDE ----------------------------------- #
-#############################################################################################
-
-
-class AzureBlobsStorageDriverOverride(AzureBlobsStorageDriver):
-    AZURE_STORAGE_CDN_URL_DATE_FORMAT = "%Y-%m-%dT%HH:%M:%SZ"
-
-    def __init__(
-        self,
-        key,
-        secret=None,
-        **kwargs,
-    ):
-        self.secret_raw = secret
-        super().__init__(key, secret, **kwargs)
-
-    def get_object_cdn_url(self, obj: Object, ex_expiry: float = 24, **kwargs):
-        sas = generate_blob_sas(
-            self.key,
-            obj.container.name,
-            obj.name,
-            account_key=self.secret_raw,
-            permission="r",
-            expiry=datetime.utcnow() + timedelta(hours=ex_expiry),
-            **kwargs,
-        )
-
-        return "{scheme}://{host}:{port}{action}?{sas_token}".format(
-            scheme="https" if self.secure else "http",
-            host=self.connection.host,
-            port=self.connection.port,
-            action=self.connection.morph_action_hook(
-                self._get_object_path(obj.container, obj.name)
-            ),
-            sas_token=sas,
-        )
-
-
-overrided_providers = {Provider.AZURE_BLOBS: AzureBlobsStorageDriverOverride}
-
-
-def get_driver(provider):
-    return overrided_providers.get(provider) or _get_driver(provider)

jaseci/extens/svc/stripe_svc.py

@@ -1,51 +0,0 @@
-import stripe
-from jaseci.jsorc.jsorc import JsOrc
-
-#################################################
-#                  STRIPE APP                   #
-#################################################
-
-
-@JsOrc.service("stripe", config="STRIPE_CONFIG")
-class StripeService(JsOrc.CommonService):
-    ###################################################
-    #                     BUILDER                     #
-    ###################################################
-
-    def run(self):
-        self.app = stripe
-        if not self.config.get("api_key"):
-            raise Exception("api_key is required!")
-        self.app.api_key = self.config.get("api_key")
-
-        if not self.config.get("webhook_key"):
-            raise Exception("webhook_key is required!")
-        self.webhook_key = self.config.get("webhook_key")
-
-        self.fallback_walker = self.config.get("fallback_walker")
-        if not self.fallback_walker:
-            raise Exception("fallback_walker is required!")
-
-        self.event_walker = self.config.get("event_walker", {})
-
-    ####################################################
-    #               COMMON GETTER/SETTER               #
-    ####################################################
-
-    def get_walker(self, event):
-        return self.event_walker.get(event) or self.fallback_walker
-
-    def get_event(self, body, headers):
-        return stripe.Webhook.construct_event(
-            body,
-            headers.get("Stripe-Signature"),
-            self.webhook_key,
-        )
-
-    ####################################################
-    #                    OVERRIDDEN                    #
-    ####################################################
-
-    def reset(self, hook, start=True):
-        stripe.api_key = None
-        super().reset(hook, start)