eclypse 0.1__tar.gz

eclypse-0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Valerio De Caro & Jacopo Massa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

eclypse-0.1/PKG-INFO

@@ -0,0 +1,4 @@
+Metadata-Version: 2.1
+Name: eclypse
+Version: 0.1
+License-File: LICENSE

eclypse-0.1/README.md

@@ -0,0 +1,31 @@
+<p align="center">
+<picture>
+    <source media="(prefers-color-scheme: dark)" srcset="docs/_static/images/dark.png"><img width=450 alt="dips-logo" src="docs/_static/images/light.png"/>
+</picture>
+</p>
+
+[![codecov](https://codecov.io/gh/eclypse-org/eclypse/graph/badge.svg?token=3BKF8SX0HK)](https://codecov.io/gh/eclypse-org/eclypse)
+![Python Version from PEP 621 TOML](https://img.shields.io/python/required-version-toml?tomlFilePath=https%3A%2F%2Fraw.githubusercontent.com%2Feclypse-org%2Feclypse%2Fmain%2Fpyproject.toml)
+[![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&)](https://github.com/pre-commit/pre-commit)
+[![Checked with mypy](http://www.mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org/)
+[![Checked wit pylint](https://img.shields.io/badge/pylint-10/10-green)](https://pylint.pycqa.org/en/latest/)
+
+[![Import sorted with isort](https://img.shields.io/badge/isort-checked-brightgreen)](https://pycqa.github.io/isort/)
+[![IMport cleaned with pycln](https://img.shields.io/badge/pycln-checked-brightgreen)](https://github.com/hadialqattan/pycln)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-black)](https://github.com/psf/black)
+[![Doc style: docformatter](https://img.shields.io/badge/doc%20style-docformatter-black)](https://github.com/PyCQA/docformatter)
+
+**ECLYPSE** (**E**dge-**CL**oud p**Y**thon **P**latform for **S**imulated runtime **E**nvironments) is the first simulation library entirely written in Python , for experimenting with deployment strategies in varying infrastructure conditions. It provides an interface to simulate deployments of service-based applications onto life-like infrastructures, without and with an actual application implementation to be deployed.
+
+## Installation
+
+To install ECLYPSE you can run the following commands:
+```bash
+
+git clone https://github/eclypse-org/eclypse
+cd eclypse
+make install
+
+```
+
+**N.B.** We **strongly** suggest the installation of ECLYPSE in a virtual environment.

eclypse-0.1/eclypse/__init__.py

@@ -0,0 +1,7 @@
+# pylint: disable=missing-module-docstring
+import os
+
+__version__ = "0.5.1"
+
+os.environ["RAY_DEDUP_LOGS"] = "0"
+os.environ["RAY_COLOR_PREFIX"] = "1"

eclypse-0.1/eclypse/builders/__init__.py

@@ -0,0 +1,6 @@
+"""Package for the application and infrastructure builders."""
+
+from . import infrastructure
+from . import application
+
+__all__ = ["infrastructure", "application"]

eclypse-0.1/eclypse/builders/application/__init__.py

@@ -0,0 +1,8 @@
+"""Module for the application builders. It has the following builders:
+
+- SockShop: A microservice-based application that simulates an e-commerce platform, made of 7 microservices.
+"""
+
+from .sock_shop.application import get_sock_shop
+
+__all__ = ["get_sock_shop"]

eclypse-0.1/eclypse/builders/application/sock_shop/__init__.py

@@ -0,0 +1,8 @@
+"""Module for the Sock Shop application builder. It provides a getter function to create
+a Sock Shop application in 3 different configurations, by choosing the `communication
+interface` in the getter:
+
+- "None": The application graph without any remote Service configuration.
+- "rest": The application graph with REST Services.
+- "mpi": The application graph with MPI Services.
+"""

eclypse-0.1/eclypse/builders/application/sock_shop/application.py

@@ -0,0 +1,258 @@
+# pylint: disable=unnecessary-lambda-assignment,import-outside-toplevel
+"""The Sock Shop application."""
+
+from __future__ import annotations
+
+from typing import (
+    TYPE_CHECKING,
+    Callable,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    Union,
+)
+
+from eclypse.graph import (
+    Application,
+    NodeGroup,
+)
+from eclypse.core.utils.tools import prune_assets
+
+if TYPE_CHECKING:
+    from networkx.classes.reportviews import (
+        EdgeView,
+        NodeView,
+    )
+
+    from eclypse.graph.assets import Asset
+
+
+def get_sock_shop(
+    application_id: str = "SockShop",
+    communication_interface: Optional[Literal["mpi", "rest"]] = None,
+    node_update_policy: Optional[Callable[[NodeView], None]] = None,
+    edge_update_policy: Optional[Callable[[EdgeView], None]] = None,
+    node_assets: Optional[Dict[str, Asset]] = None,
+    edge_assets: Optional[Dict[str, Asset]] = None,
+    include_default_assets: bool = True,
+    requirement_init: Literal["min", "max"] = "min",
+    flows: Union[Literal["default"], List[List[str]]] = "default",
+    seed: Optional[int] = None,
+) -> Application:
+    """Get the Sock Shop application.
+
+    Args:
+        application_id (str): The ID of the application.
+        communication_interface (Optional[Literal["mpi", "rest"]]): The communication interface.
+        node_update_policy (Optional[Callable[[NodeView], None]]): A function to update the nodes.
+        edge_update_policy (Optional[Callable[[EdgeView], None]]): A function to update the edges.
+        node_assets (Optional[Dict[str, Asset]]): The assets of the nodes.
+        edge_assets (Optional[Dict[str, Asset]]): The assets of the edges.
+        include_default_assets (bool): Whether to include the default assets.
+        requirement_init (Literal["min", "max"]): The initialization of the requirements.
+        flows (Optional[List[List[str]]): The flows of the application.
+        seed (Optional[int]): The seed for the random number generator.
+
+    Returns:
+        Application: The Sock Shop application.
+    """
+    if flows == "default":
+        _flows = [
+            ["FrontendService", "UserService", "FrontendService"],  # Login
+            ["FrontendService", "CatalogService", "FrontendService"],  # Browsing
+            [
+                "FrontendService",
+                "CatalogService",
+                "CartService",
+                "FrontendService",
+            ],  # Adding to cart
+            [
+                "FrontendService",
+                "PaymentService",
+                "OrderService",
+                "ShippingService",
+                "FrontendService",
+            ],  # Checkout
+            [
+                "FrontendService",
+                "OrderService",
+                "ShippingService",
+                "FrontendService",
+            ],  # Shipping monitoring
+        ]
+    else:
+        _flows = flows
+
+    app = Application(
+        application_id=application_id,
+        node_update_policy=node_update_policy,
+        edge_update_policy=edge_update_policy,
+        node_assets=node_assets,
+        edge_assets=edge_assets,
+        include_default_assets=include_default_assets,
+        requirement_init=requirement_init,
+        flows=_flows,
+        seed=seed,
+    )
+
+    if communication_interface is None:
+        add_fn = app.add_node_by_group
+        id_fn = lambda service: service
+    elif communication_interface in ["mpi", "rest"]:
+        add_fn = app.add_service_by_group  # type: ignore[assignment]
+        if communication_interface == "mpi":
+            from . import mpi_services as services
+        else:
+            from . import rest_services as services  # type: ignore[no-redef]
+
+        classes = {
+            "CatalogService": services.CatalogService,
+            "UserService": services.UserService,
+            "CartService": services.CartService,
+            "OrderService": services.OrderService,
+            "PaymentService": services.PaymentService,
+            "ShippingService": services.ShippingService,
+            "FrontendService": services.FrontendService,
+        }
+        id_fn = lambda service: classes[service](service)
+    else:
+        raise ValueError(f"Unknown communication interface: {communication_interface}")
+
+    add_fn(
+        NodeGroup.FAR_EDGE,
+        id_fn("UserService"),
+        **prune_assets(
+            app.node_assets,
+            cpu=1,
+            gpu=0,
+            ram=0.75,
+            storage=0.3,
+            availability=0.91,
+            processing_time=10,
+        ),
+    )
+    add_fn(
+        NodeGroup.FAR_EDGE,
+        id_fn("FrontendService"),
+        **prune_assets(
+            app.node_assets,
+            cpu=1,
+            gpu=0,
+            ram=0.75,
+            storage=0.3,
+            availability=0.94,
+            processing_time=30,
+        ),
+    )
+    add_fn(
+        NodeGroup.FAR_EDGE,
+        id_fn("CatalogService"),
+        **prune_assets(
+            app.node_assets,
+            cpu=1,
+            gpu=0,
+            ram=1.5,
+            storage=0.75,
+            availability=0.91,
+            processing_time=12.5,
+        ),
+    )
+    add_fn(
+        NodeGroup.NEAR_EDGE,
+        id_fn("OrderService"),
+        **prune_assets(
+            app.node_assets,
+            cpu=2,
+            gpu=0,
+            ram=3.0,
+            storage=0.75,
+            availability=0.92,
+            processing_time=20,
+        ),
+    )
+    add_fn(
+        NodeGroup.NEAR_EDGE,
+        id_fn("CartService"),
+        **prune_assets(
+            app.node_assets,
+            cpu=1,
+            gpu=0,
+            ram=0.75,
+            storage=0.3,
+            availability=0.91,
+            processing_time=10,
+        ),
+    )
+    add_fn(
+        NodeGroup.NEAR_EDGE,
+        id_fn("PaymentService"),
+        **prune_assets(
+            app.node_assets,
+            cpu=1,
+            gpu=0,
+            ram=0.75,
+            storage=0.3,
+            availability=0.95,
+            processing_time=12.5,
+        ),
+    )
+    add_fn(
+        NodeGroup.NEAR_EDGE,
+        id_fn("ShippingService"),
+        **prune_assets(
+            app.node_assets,
+            cpu=1,
+            gpu=0,
+            ram=0.75,
+            storage=0.3,
+            availability=0.915,
+            processing_time=17.5,
+        ),
+    )
+
+    app.add_edge_by_group(
+        "FrontendService",
+        "CatalogService",
+        symmetric=True,
+        latency=40,
+        bandwidth=2,
+    )
+    app.add_edge_by_group(
+        "FrontendService",
+        "UserService",
+        symmetric=True,
+        latency=40,
+        bandwidth=2,
+    )
+    app.add_edge_by_group(
+        "FrontendService",
+        "CartService",
+        symmetric=True,
+        latency=40,
+        bandwidth=2,
+    )
+    app.add_edge_by_group(
+        "FrontendService",
+        "OrderService",
+        symmetric=True,
+        latency=50,
+        bandwidth=10,
+    )
+
+    app.add_edge_by_group(
+        "OrderService",
+        "PaymentService",
+        symmetric=True,
+        latency=50,
+        bandwidth=10,
+    )
+    app.add_edge_by_group(
+        "OrderService",
+        "ShippingService",
+        symmetric=True,
+        latency=70,
+        bandwidth=10,
+    )
+
+    return app

eclypse-0.1/eclypse/builders/application/sock_shop/mpi_services/__init__.py

@@ -0,0 +1,19 @@
+# pylint: disable=missing-module-docstring,duplicate-code
+
+from .catalog import CatalogService
+from .user import UserService
+from .cart import CartService
+from .order import OrderService
+from .payment import PaymentService
+from .shipping import ShippingService
+from .frontend import FrontendService
+
+__all__ = [
+    "CatalogService",
+    "UserService",
+    "CartService",
+    "OrderService",
+    "PaymentService",
+    "ShippingService",
+    "FrontendService",
+]

eclypse-0.1/eclypse/builders/application/sock_shop/mpi_services/cart.py

@@ -0,0 +1,50 @@
+"""The `CartService` handles the shopping cart functionality, allowing users to manage \
+
+their desired items before making a purchase.
+- Key Responsibilities:
+    - Manages the user’s shopping cart by adding, removing, or updating items.
+    - Stores cart data temporarily for guest users or long-term for registered users.
+"""
+
+from eclypse.core.remote.communication import mpi
+from eclypse.core.remote.service import ServiceEngine
+
+
+class CartService(ServiceEngine):
+    """MPI workflow of the Cart service."""
+
+    async def dispatch(self):
+        """Example workflow of the Cart service, starting with fetching \ the user's
+        cart data."""
+        await self.frontend_request()  # pylint: disable=no-value-for-parameter
+
+    @mpi.exchange(receive=True, send=True)
+    def frontend_request(self, sender_id, body):
+        """Process the frontend request and send the response to the `FrontendService`.
+
+        Args:
+            sender_id (str): The ID of the sender.
+            body (dict): The request body.
+
+        Returns:
+            str: The ID of the recipient.
+            dict: The response body.
+        """
+        self.logger.info(f"{self.id} - {body}")
+
+        # Send response to FrontendService
+        if body.get("request_type") == "cart_data":
+            frontend_response = {
+                "response_type": "cart_response",
+                "items": [
+                    {"product_id": "1", "quantity": 2},
+                    {"product_id": "2", "quantity": 1},
+                ],
+            }
+        else:
+            frontend_response = {
+                "response_type": "cart_response",
+                "status": "Invalid request",
+            }
+
+        return sender_id, frontend_response

eclypse-0.1/eclypse/builders/application/sock_shop/mpi_services/catalog.py

@@ -0,0 +1,51 @@
+"""The `CatalogService` is responsible for managing and serving product information.
+
+- Key Responsibilities:
+    -
+    - Supports operations such as searching for products and listing available items \
+    in the store.
+    - Interfaces with the underlying data store to fetch product data.
+"""
+
+from eclypse.core.remote.communication import mpi
+from eclypse.core.remote.service import ServiceEngine
+
+
+class CatalogService(ServiceEngine):
+    """MPI workflows for the Catalog service."""
+
+    async def dispatch(self):
+        """The `CatalogService` workflow consists of receiving a request from the \
+        `FrontendService` and sending a response containing product information."""
+
+    @mpi.exchange(receive=True, send=True)
+    def frontend_request(self, sender_id, body):
+        """Process requests from the FrontendService and send responses back.
+
+        Args:
+            sender_id (str): The ID of the sender.
+            body (dict): The request body.
+
+        Returns:
+            str: The ID of the recipient.
+            dict: The response body.
+        """
+        self.logger.info(f"{self.id} - {body}")
+
+        # Send response to FrontendService
+        if body.get("request_type") == "catalog_data":
+
+            frontend_response = {
+                "response_type": "catalog_response",
+                "products": [
+                    {"id": "1", "name": "Product 1", "price": 19.99},
+                    {"id": "2", "name": "Product 2", "price": 29.99},
+                ],
+            }
+        else:
+            frontend_response = {
+                "response_type": "catalog_response",
+                "status": "Invalid request",
+            }
+
+        return sender_id, frontend_response

eclypse-0.1/eclypse/builders/application/sock_shop/mpi_services/frontend.py

@@ -0,0 +1,72 @@
+"""The `FrontendService` serves as the user interface for the SockShop application, \
+
+    providing the user-facing components of the store.
+- Key Responsibilities:
+    - Displays product catalogs, shopping carts, and order information to users.
+    - Interacts with backend services \
+        (e.g., `CatalogService`, `UserService`, `OrderService`) to display real-time data.
+    - Manages user input and interactions such as product searches, \
+        cart updates, and order placements.
+"""
+
+from eclypse.core.remote.communication import mpi
+from eclypse.core.remote.service import ServiceEngine
+
+
+class FrontendService(ServiceEngine):
+    """MPI workflow of the Frontend service."""
+
+    def __init__(self, name):
+        super().__init__(name)
+        self.user_id = 12345
+
+    async def dispatch(self):
+        """Example workflow of the Frontend service, starting with fetching the catalog,
+        \ user data, and cart items, then placing an order."""
+        # Send request to CatalogService
+        await self.catalog_request()
+
+        # Receive response from CatalogService
+        catalog_response = await self.mpi.recv()
+
+        self.logger.info(f"{self.id} - {catalog_response}")
+
+        # Send request to UserService
+        user_request = {"request_type": "user_data", "user_id": self.user_id}
+        self.mpi.send("UserService", user_request)
+
+        # Receive response from UserService
+        user_response = await self.mpi.recv()
+        self.logger.info(f"{self.id} - {user_response}")
+
+        # Send request to CartService
+        cart_request = {"request_type": "cart_data", "user_id": self.user_id}
+        self.mpi.send("CartService", cart_request)
+
+        # Receive response from CartService
+        cart_response = await self.mpi.recv()
+        self.logger.info(f"{self.id} - {cart_response}")
+
+        cart_items = cart_response.get("items", [])
+
+        # Send request to OrderService
+        order_request = {
+            "request_type": "order_request",
+            "user_id": self.user_id,
+            "items": cart_items,
+        }
+        self.mpi.send("OrderService", order_request)
+
+        # Receive response from OrderService
+        order_response = await self.mpi.recv()
+        self.logger.info(f"{self.id} - {order_response}")
+
+    @mpi.exchange(send=True)
+    def catalog_request(self):
+        """Send a request to the CatalogService for product data.
+
+        Returns:
+            str: The recipient service name.
+            dict: The request body.
+        """
+        return "CatalogService", {"request_type": "catalog_data"}

eclypse-0.1/eclypse/builders/application/sock_shop/mpi_services/order.py

@@ -0,0 +1,111 @@
+# pylint: disable=no-value-for-parameter
+"""The `OrderService` processes user orders, ensuring the coordination between \
+
+    different services like payment, inventory, and shipping.
+- Key Responsibilities:
+    - Creates, updates, and manages customer orders.
+    - Interacts with the `PaymentService` and `ShippingService` to complete the order transaction.
+    - Tracks the status of placed orders (e.g., pending, confirmed, shipped).
+"""
+
+import random as rnd
+
+from eclypse.core.remote.communication import mpi
+from eclypse.core.remote.service import ServiceEngine
+
+
+class OrderService(ServiceEngine):
+    """MPI workflow of the Order service."""
+
+    def __init__(self, name):
+        super().__init__(name)
+        self.order_id = 54321
+        self.transaction_id = None
+        self.shipping_details = {}
+        self.items = []
+
+    async def dispatch(self):
+        """Example workflow of the Order service, starting with processing the order \
+        request, then sending requests to the `PaymentService` and `ShippingService`."""
+        await self.frontend_request()
+        await self.payment_request()
+        await self.shipping_request()
+
+    @mpi.exchange(receive=True, send=True)
+    def frontend_request(self, _, body):
+        """Process the frontend request and send the response to the `PaymentService`.
+
+        Args:
+            body (dict): The request body.
+
+        Returns:
+            str: The ID of the recipient.
+            dict: The response body.
+        """
+
+        self.logger.info(f"{self.id} - {body}")
+
+        self.items = body.get("items", [])
+        total_amount = sum(rnd.randint(20, 100) for _ in self.items)
+
+        # Send request to PaymentService
+        payment_request = {
+            "request_type": "payment_request",
+            "order_id": self.order_id,
+            "amount": total_amount,
+        }
+
+        return "PaymentService", payment_request
+
+    @mpi.exchange(receive=True, send=True)
+    def payment_request(self, _, body):
+        """Process the payment request and send the response to the `ShippingService`.
+
+        Args:
+            body (dict): The request body.
+
+        Returns:
+            str: The ID of the recipient.
+            dict: The response body.
+        """
+        self.logger.info(f"{self.id} - {body}")
+
+        self.transaction_id = body.get("transaction_id")
+        # Send request to ShippingService
+        shipping_request = {
+            "request_type": "shipping_request",
+            "order_id": self.order_id,
+        }
+
+        return "ShippingService", shipping_request
+
+    @mpi.exchange(receive=True, send=True)
+    def shipping_request(self, _, body):
+        """Process the shipping request and send the response to the `FrontendService`.
+
+        Args:
+            body (dict): The request body.
+
+        Returns:
+            str: The ID of the recipient.
+            dict: The response body.
+        """
+        self.logger.info(f"{self.id} - {body}")
+
+        self.shipping_details = body.get("details")
+
+        # Send response to FrontendService
+        if self.transaction_id is not None:
+            order_response = {
+                "response_type": "order_response",
+                "status": "success",
+                "shipping_details": self.shipping_details,
+                "transaction_id": self.transaction_id,
+            }
+        else:
+            order_response = {
+                "response_type": "order_response",
+                "status": "failure",
+            }
+
+        return "FrontendService", order_response