cluster-builder 0.1.0__py3-none-any.whl

cluster_builder/__init__.py

@@ -0,0 +1,10 @@
+"""
+Cluster Builder - A tool for creating, managing, and destroying K3s clusters.
+"""
+
+from cluster_builder.swarmchestrate import Swarmchestrate
+from cluster_builder.utils.logging import configure_logging
+
+configure_logging()
+
+__all__ = ["Swarmchestrate"]

cluster_builder/swarmchestrate.py

@@ -0,0 +1,355 @@
+"""
+Swarmchestrate - Main orchestration class for K3s cluster management.
+"""
+
+import os
+import logging
+import shutil
+from typing import Optional
+
+from dotenv import load_dotenv
+
+from cluster_builder.config.postgres import PostgresConfig
+from cluster_builder.config.cluster import ClusterConfig
+from cluster_builder.templates.manager import TemplateManager
+from cluster_builder.infrastructure.executor import CommandExecutor
+from cluster_builder.utils import hcl
+
+logger = logging.getLogger("swarmchestrate")
+
+
+class Swarmchestrate:
+    """
+    Main class for orchestrating K3s clusters across different cloud providers.
+    """
+
+    def __init__(
+        self,
+        template_dir: str,
+        output_dir: str,
+        variables: Optional[dict[str, any]] = None,
+    ):
+        """
+        Initialise the Swarmchestrate class.
+
+        Args:
+            template_dir: Directory containing templates
+            output_dir: Directory for outputting generated files
+            variables: Optional additional variables for deployments
+        """
+        self.template_dir = f"{template_dir}"
+        self.output_dir = output_dir
+
+        load_dotenv()
+
+        try:
+            self.pg_config = PostgresConfig.from_env()
+        except ValueError as e:
+            logger.error(f"Invalid PostgreSQL configuration: {e}")
+            raise
+
+        # Initialise components
+        self.template_manager = TemplateManager()
+        self.cluster_config = ClusterConfig(
+            self.template_manager, output_dir, self.pg_config
+        )
+
+        logger.info(
+            f"Initialised with template_dir={template_dir}, output_dir={output_dir}"
+        )
+
+    def get_cluster_output_dir(self, cluster_name: str) -> str:
+        """
+        Get the output directory path for a specific cluster.
+
+        Args:
+            cluster_name: Name of the cluster
+
+        Returns:
+            Path to the cluster output directory
+        """
+        return self.cluster_config.get_cluster_output_dir(cluster_name)
+
+    def generate_random_name(self) -> str:
+        """
+        Generate a readable random string using names-generator.
+
+        Returns:
+            A randomly generated name
+        """
+        return self.cluster_config.generate_random_name()
+
+    def _validate_node_config(self, config: dict[str, any]) -> None:
+        """
+        Validate node configuration.
+
+        Args:
+            config: Configuration dictionary
+
+        Raises:
+            ValueError: If configuration is invalid
+        """
+        # Check required fields
+        if "cloud" not in config:
+            raise ValueError("Cloud provider must be specified in configuration")
+
+        if "k3s_role" not in config:
+            raise ValueError("K3s role must be specified in configuration")
+
+        # Master IP validation
+        has_master_ip = "master_ip" in config and config["master_ip"]
+        role = config["k3s_role"]
+
+        # Cannot add a master node to an existing cluster
+        if has_master_ip and role == "master":
+            raise ValueError(
+                "Cannot add a master node to an existing cluster (master_ip specified with master role)"
+            )
+
+        # Worker/HA nodes require a master IP
+        if not has_master_ip and role in ["worker", "ha"]:
+            raise ValueError(f"Role '{role}' requires master_ip to be specified")
+
+    def prepare_infrastructure(
+        self, config: dict[str, any]
+    ) -> tuple[str, dict[str, any]]:
+        """
+        Prepare infrastructure configuration for deployment.
+
+        This method prepares the necessary files and configuration for deployment
+        but does not actually deploy the infrastructure.
+
+        Args:
+            config: Configuration dictionary containing cloud, k3s_role, and
+                optionally cluster_name and master_ip
+
+        Returns:
+            Tuple containing the cluster directory path and updated configuration
+
+        Raises:
+            ValueError: If required configuration is missing or invalid
+            RuntimeError: If file operations fail
+        """
+        try:
+            # Validate the configuration
+            self._validate_node_config(config)
+
+            # Prepare the configuration and files
+            cluster_dir, prepared_config = self.cluster_config.prepare(config)
+
+            # Create provider configuration
+            cloud = config["cloud"]
+            self.template_manager.create_provider_config(cluster_dir, cloud)
+            logger.info(f"Created provider configuration for {cloud}")
+
+            # Create Terraform files
+            main_tf_path = os.path.join(cluster_dir, "main.tf")
+            backend_tf_path = os.path.join(cluster_dir, "backend.tf")
+
+            # Add backend configuration
+            hcl.add_backend_config(
+                backend_tf_path,
+                prepared_config["pg_conn_str"],
+                prepared_config["cluster_name"],
+            )
+            logger.info(f"Added backend configuration to {backend_tf_path}")
+
+            # Add module block
+            target = prepared_config["resource_name"]
+            hcl.add_module_block(main_tf_path, target, prepared_config)
+            logger.info(f"Added module block to {main_tf_path}")
+
+            return cluster_dir, prepared_config
+
+        except Exception as e:
+            error_msg = f"Failed to prepare infrastructure: {e}"
+            logger.error(error_msg)
+            raise RuntimeError(error_msg)
+
+    def add_node(self, config: dict[str, any], dryrun: bool = False) -> str:
+        """
+        Add a node to an existing cluster or create a new cluster based on configuration.
+
+        If master_ip is provided, adds a node to that cluster.
+        If master_ip is not provided, creates a new cluster.
+
+        Args:
+            config: Configuration dictionary containing cloud, k3s_role, and
+                   optionally cluster_name and master_ip
+            dryrun: If True, only validate the configuration without deploying
+
+        Returns:
+            The cluster name
+
+        Raises:
+            ValueError: If required configuration is missing or invalid
+            RuntimeError: If preparation or deployment fails
+        """
+        # Prepare the infrastructure configuration
+        cluster_dir, prepared_config = self.prepare_infrastructure(config)
+
+        logger.info(f"Adding node for cluster '{prepared_config['cluster_name']}'")
+
+        # Deploy the infrastructure
+        try:
+            self.deploy(cluster_dir, dryrun)
+            cluster_name = prepared_config["cluster_name"]
+            node_name = prepared_config["resource_name"]
+            logger.info(
+                f"Successfully added '{node_name}' for cluster '{cluster_name}'"
+            )
+            return cluster_name
+        except Exception as e:
+            error_msg = f"Failed to add node: {e}"
+            logger.error(error_msg)
+            raise RuntimeError(error_msg)
+
+    def remove_node(
+        self, cluster_name: str, resource_name: str, dryrun: bool = False
+    ) -> None:
+        """
+        Remove a specific node from a cluster.
+
+        This method removes a node's infrastructure component from a cluster by
+        removing its module block from the Terraform configuration and then
+        reapplying the configuration.
+
+        Args:
+            cluster_name: Name of the cluster containing the node
+            resource_name: Resource name of the node to remove
+            dryrun: If True, only validate the changes without applying
+
+        Raises:
+            RuntimeError: If node removal fails
+        """
+        logger.info(f"Removing node '{resource_name}' from cluster '{cluster_name}'...")
+
+        # Get the directory for the specified cluster
+        cluster_dir = self.get_cluster_output_dir(cluster_name)
+
+        if not os.path.exists(cluster_dir):
+            error_msg = f"Cluster directory '{cluster_dir}' not found"
+            logger.error(error_msg)
+            raise RuntimeError(error_msg)
+
+        # Path to main.tf
+        main_tf_path = os.path.join(cluster_dir, "main.tf")
+
+        if not os.path.exists(main_tf_path):
+            error_msg = f"Main Terraform file not found: {main_tf_path}"
+            logger.error(error_msg)
+            raise RuntimeError(error_msg)
+
+        try:
+            # Remove the module block for the specified resource
+            hcl.remove_module_block(main_tf_path, resource_name)
+            logger.info(
+                f"Removed module block for '{resource_name}' from {main_tf_path}"
+            )
+
+            self.deploy(cluster_dir, dryrun)
+
+            if not dryrun:
+                logger.info(
+                    f"Successfully removed node '{resource_name}' from cluster '{cluster_name}'"
+                )
+
+        except Exception as e:
+            error_msg = f"Failed to remove node '{resource_name}' from cluster '{cluster_name}': {str(e)}"
+            logger.error(error_msg)
+            raise RuntimeError(error_msg)
+
+    def deploy(self, cluster_dir: str, dryrun: bool = False) -> None:
+        """
+        Execute OpenTofu commands to deploy the K3s component with error handling.
+
+        Args:
+            cluster_dir: Directory containing the Terraform files for the cluster
+            dryrun: If True, only run init and plan without applying
+
+        Raises:
+            RuntimeError: If OpenTofu commands fail
+        """
+        logger.info(f"Updating infrastructure in {cluster_dir}")
+
+        if not os.path.exists(cluster_dir):
+            error_msg = f"Cluster directory '{cluster_dir}' not found"
+            logger.error(error_msg)
+            raise RuntimeError(error_msg)
+
+        try:
+            # Initialise OpenTofu
+            init_command = ["tofu", "init"]
+            if dryrun:
+                logger.info("Dryrun: will init without backend and validate only")
+                init_command.append("-backend=false")
+            CommandExecutor.run_command(init_command, cluster_dir, "OpenTofu init")
+
+            # Validate the deployment
+            if dryrun:
+                CommandExecutor.run_command(
+                    ["tofu", "validate"], cluster_dir, "OpenTofu validate"
+                )
+                logger.info("Infrastructure successfully validated")
+                return
+
+            # Plan the deployment
+            CommandExecutor.run_command(["tofu", "plan"], cluster_dir, "OpenTofu plan")
+
+            # Apply the deployment
+            CommandExecutor.run_command(
+                ["tofu", "apply", "-auto-approve"], cluster_dir, "OpenTofu apply"
+            )
+            logger.info("Infrastructure successfully updated")
+
+        except RuntimeError as e:
+            error_msg = f"Failed to deploy infrastructure: {str(e)}"
+            logger.error(error_msg)
+            raise RuntimeError(error_msg)
+
+    def destroy(self, cluster_name: str, dryrun: bool = False) -> None:
+        """
+        Destroy the deployed K3s cluster for the specified cluster_name using OpenTofu.
+
+        Args:
+            cluster_name: Name of the cluster to destroy
+
+        Raises:
+            RuntimeError: If destruction fails
+        """
+        logger.info(f"Destroying the K3s cluster '{cluster_name}'...")
+
+        # Get the directory for the specified cluster
+        cluster_dir = self.get_cluster_output_dir(cluster_name)
+
+        if not os.path.exists(cluster_dir):
+            error_msg = f"Cluster directory '{cluster_dir}' not found"
+            logger.error(error_msg)
+            raise RuntimeError(error_msg)
+
+        if dryrun:
+            logger.info("Dryrun: will only delete")
+            shutil.rmtree(cluster_dir, ignore_errors=True)
+            return
+
+        try:
+            # Plan destruction
+            CommandExecutor.run_command(
+                ["tofu", "plan", "-destroy"], cluster_dir, "OpenTofu plan destruction"
+            )
+
+            # Execute destruction
+            CommandExecutor.run_command(
+                ["tofu", "destroy", "-auto-approve"], cluster_dir, "OpenTofu destroy"
+            )
+
+            logger.info(f"Cluster '{cluster_name}' destroyed successfully")
+
+            # Remove the cluster directory
+            shutil.rmtree(cluster_dir, ignore_errors=True)
+            logger.info(f"Removed cluster directory: {cluster_dir}")
+
+        except RuntimeError as e:
+            error_msg = f"Failed to destroy cluster '{cluster_name}': {str(e)}"
+            logger.error(error_msg)
+            raise RuntimeError(error_msg)

cluster_builder-0.1.0.dist-info/METADATA

@@ -0,0 +1,265 @@
+Metadata-Version: 2.4
+Name: cluster-builder
+Version: 0.1.0
+Summary: Swarmchestrate cluster builder
+Author-email: Gunjan <G.Kotak@westminster.ac.uk>, Jay <J.Deslauriers@westminster.ac.uk>
+License: Apache2
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: names_generator
+Requires-Dist: python-hcl2
+Requires-Dist: lark-parser
+Requires-Dist: jinja2
+Requires-Dist: python-dotenv
+Dynamic: license-file
+
+# Swarmchestrate - Cluster Builder
+
+This repository contains the codebase for **[cluster-builder]**, which builds K3s clusters for Swarmchestrate using OpenTofu.  
+
+Key features:
+- **Create**: Provisions infrastructure using OpenTofu and installs K3s.
+- **Add**: Add worker or HA nodes to existing clusters.
+- **Remove**: Selectively remove nodes from existing clusters.  
+- **Delete**: Destroys the provisioned infrastructure when no longer required. 
+
+---
+
+## Prerequisites
+
+Before proceeding, ensure the following prerequisites are installed:
+
+1. **Git**: For cloning the repository.
+2. **Python**: Version 3.9 or higher.
+3. **pip**: Python package manager.
+4. **OpenTofu**: Version 1.6 or higher for infrastructure provisioning.
+6. **Make**: To run the provided `Makefile`.
+7. **PostgreSQL**: For storing OpenTofu state.
+8. (Optional) **Docker**: To create a dev Postgres
+---
+
+## Getting Started
+
+### 1. Clone the Repository
+
+To get started, clone this repository:
+
+```bash
+git clone https://github.com/Swarmchestrate/cluster-builder.git
+ ```
+
+### 2. Navigate to the Project Directory
+
+```bash
+cd cluster-builder
+ ```
+
+### 3. Install Dependencies and Tools
+
+Run the Makefile to install all necessary dependencies, including OpenTofu:
+
+```bash
+ make install
+```
+
+This command will:
+- Install Python dependencies listed in requirements.txt.
+- Download and configure OpenTofu for infrastructure management.
+
+**Optional**
+
+```bash
+ make db
+```
+
+This command will:
+- Spin up an empty dev Postgres DB (in Docker) for storing state
+
+### 4. Populate .env file with access config
+
+First, rename or copy the example file to `.env`
+
+```bash
+cp .env_example .env
+```
+
+Then populate postgres connection details and needed cloud credential data.
+
+```
+## PG Configuration
+POSTGRES_USER=postgres
+POSTGRES_PASSWORD=secret
+POSTGRES_HOST=db.example.com
+POSTGRES_DATABASE=terraform_state
+POSTGRES_SSLMODE=prefer
+
+## AWS Auth
+AWS_REGION=us-west-2
+AWS_ACCESS_KEY=AKIAXXXXXXXXXXXXXXXX
+AWS_SECRET_KEY=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+```
+
+---
+
+## Basic Usage
+
+### Initialisation
+
+```python
+from cluster_builder import Swarmchestrate
+
+# Initialise the orchestrator
+orchestrator = Swarmchestrate(
+    template_dir="/path/to/templates",
+    output_dir="/path/to/output"
+)
+```
+
+### Creating a New Cluster
+
+To create a new k3s cluster, use the `add_node` method with the `master` role:
+
+```python
+# Configuration for a new cluster
+config = {
+    "cloud": "aws",
+    "k3s_role": "master",
+    "ami": "ami-0123456789abcdef",
+    "instance_type": "t3.medium",
+    "ssh_key_name": "your-ssh-key",
+    "k3s_token": "your-k3s-token"
+}
+
+# Create the cluster (returns the cluster name)
+cluster_name = orchestrator.add_node(config)
+print(f"Created cluster: {cluster_name}")
+```
+
+### Adding Nodes to an Existing Cluster
+
+To add worker or high-availability nodes to an existing cluster:
+
+```python
+# Configuration for adding a worker node
+worker_config = {
+    "cloud": "aws",
+    "k3s_role": "worker",  # can be "worker" or "ha"
+    "master_ip": "1.2.3.4",  # IP of the master node
+    "cluster_name": "existing-cluster-name",  # specify an existing cluster
+    "ami": "ami-0123456789abcdef",
+    "instance_type": "t2.medium",
+    "ssh_key_name": "your-ssh-key",
+    "k3s_token": "k3s-cluster-token" # Token of existing cluster
+}
+
+# Add the worker node
+cluster_name = orchestrator.add_node(worker_config)
+print(f"Added worker node to cluster: {cluster_name}")
+```
+
+Important requirements:
+- For `k3s_role="worker"` or `k3s_role="ha"`, you must specify a `master_ip`
+- For `k3s_role="master"`, you must not specify a `master_ip`
+
+### Removing a Specific Node
+
+To remove a specific node from a cluster:
+
+```python
+# Remove a node by its resource name
+orchestrator.remove_node(
+    cluster_name="your-cluster-name",
+    resource_name="aws_eloquent_feynman"  # The resource identifier of the node
+)
+```
+
+The `remove_node` method:
+1. Destroys the node's infrastructure resources
+2. Removes the node's configuration from the cluster
+
+### Destroying an Entire Cluster
+
+To completely destroy a cluster and all its nodes:
+
+```python
+# Destroy the entire cluster
+orchestrator.destroy(
+    cluster_name="your-cluster-name"
+)
+```
+
+The `destroy` method:
+1. Destroys all infrastructure resources associated with the cluster
+2. Removes the cluster directory and configuration files
+
+## Advanced Usage
+
+### Dry Run Mode
+
+All operations support a `dryrun` parameter, which validates the configuration 
+without making changes. A node created with dryrun should be removed with dryrun.
+
+```python
+# Validate configuration without deploying
+orchestrator.add_node(config, dryrun=True)
+
+# Validate removal without destroying
+orchestrator.remove_node(cluster_name, resource_name, dryrun=True)
+
+# Validate destruction without destroying
+orchestrator.destroy(cluster_name, dryrun=True)
+```
+
+### Custom Cluster Names
+
+By default, cluster names are generated automatically. To specify a custom name:
+
+```python
+config = {
+    "cloud": "aws",
+    "k3s_role": "master",
+    "cluster_name": "production-cluster",
+    # ... other configuration ...
+}
+
+orchestrator.add_node(config)
+```
+
+---
+
+## Template Structure
+
+Templates should be organised as follows:
+- `templates/` - Base directory for templates
+- `templates/{cloud}/` - Terraform modules for each cloud provider
+- `templates/{role}_user_data.sh.tpl` - Node initialisation scripts
+- `templates/{cloud}_provider.tf.j2` - Provider configuration templates
+
+---
+
+## Edge Device Requirements
+
+To connect **edge devices** as part of your K3s cluster, ensure that the following **ports are open** on each edge device to enable communication within nodes:
+
+### Inbound Rules:
+
+| Port Range| Protocol| Purpose                                                     |
+|-----------|---------|-------------------------------------------------------------|
+| 2379-2380 | TCP     | Internal servers communication for embedded etcd            |
+| 6443      | TCP     | K3s API server communication                                |
+| 8472      | UDP     | Flannel VXLAN (network overlay)                             |
+| 10250     | TCP     | Kubelet metrics and communication                           |
+| 51820     | UDP     | WireGuard IPv4 (for encrypted networking)                   |
+| 51821     | UDP     | WireGuard IPv6 (for encrypted networking)                   |
+| 5001      | TCP     | Embedded registry (Spegel)                                  |
+| 22        | TCP     | SSH access for provisioning and management                  |
+| 80        | TCP     | HTTP communication for web access                           |
+| 443       | TCP     | HTTPS communication for secure access                       |
+| 53        | UDP     | DNS (CoreDNS) for internal service discovery                |
+| 5432      | TCP     | PostgreSQL database access                                  |
+
+### Outbound Rule:
+
+| Port Range| Protocol | Purpose                                                |
+|-----------|----------|--------------------------------------------------------|
+| all       | all      | Allow all outbound traffic for the system's operations |

cluster_builder-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+cluster_builder/__init__.py,sha256=p2Rb2BTVm-ScqCKE38436WsItY1BjVAnvx7zwmneSLs,256
+cluster_builder/swarmchestrate.py,sha256=K3zWA4Ob6XVH0GDlDQW13Q3IHd1gEjHRvBfgtBLi-Wo,12471
+cluster_builder-0.1.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+cluster_builder-0.1.0.dist-info/METADATA,sha256=TLtMwDzzR5Rt79rie7_wkpKClfEbMzkNvljELcot-WM,7563
+cluster_builder-0.1.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+cluster_builder-0.1.0.dist-info/top_level.txt,sha256=fTW8EW1mcWoeWprjwxSHRWpqfXYX8iN-ByEt8HPXIcs,16
+cluster_builder-0.1.0.dist-info/RECORD,,

cluster_builder-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (78.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

cluster_builder-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

cluster_builder-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+cluster_builder