python-doniclient 1.0.3__tar.gz → 1.0.4__tar.gz

python_doniclient-1.0.4/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: python-doniclient
+Version: 1.0.4
+Summary: This is a plugin for the openstack commandline client, to enable support for the Doni hardware inventory project
+Author-email: Chameleon Cloud <contact@chameleoncloud.org>
+License-Expression: Apache-2.0
+Project-URL: Repository, https://github.com/ChameleonCloud/python-doniclient
+Classifier: Environment :: OpenStack
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: System Administrators
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: osc-lib
+Requires-Dist: python-dateutil
+Requires-Dist: PyYAML>=5.4.1
+Requires-Dist: keystoneauth1
+
+# ChameleonCloud Python Doniclient CLI
+
+![ChameleonCloud Logo](https://www.chameleoncloud.org/static/images/logo.png)
+
+Welcome to the ChameleonCloud Python Doniclient CLI repository! This command-line interface (CLI) provides a convenient way to interact with ChameleonCloud's Doni hardware inventory project, enabling you to manage and automate various hardware-related tasks.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Authentication](#authentication)
+- [Usage](#usage)
+- [Testing](#testing)
+- [Contributing](#contributing)
+
+## Installation
+
+You can install the ChameleonCloud Python Doniclient CLI using pip:
+
+```bash
+pip install python-doniclient
+```
+
+### Cython sources issue
+if you encounter an error message citing cython sources, please run the following to downgrade cython to a compatible version and use PyYaml 6.0+
+```pip install "cython<3.0.0"```
+
+## Authentication
+Environment variables are the primary authentication method. Please refer to the [documentation on OpenRC scripts](https://chameleoncloud.readthedocs.io/en/latest/technical/cli.html#the-openstack-rc-script)  to learn more about how to download and source your authentication credentials for the CLI;
+
+## Usage
+To use the CLI, you can run the `openstack hardware` command followed by the desired subcommand. `openstack hardware --help` shows all the subcommands available. Here's a basic usage examples:
+
+### List all hardware in the Doni database.
+
+```bash
+openstack hardware list
+```
+
+Options:
+
+- --all: List hardware from all owners (requires admin rights).
+- --long: Include all columns in the output.
+- --worker-type <worker_type>: Filter by worker type.
+- --worker-state <worker_state>: Filter by worker state (choices: PENDING, IN_PROGRESS, ERROR, STEADY).
+
+For more details on specific commands and their options use --help or -h
+
+### Create hardware in the Doni database
+
+```bash
+openstack hardware create --name <hardware_name> --hardware-type <hardware_type> --property <property_name>=<property_value>
+```
+
+### List specific hardware item in Doni using name or uuid.
+
+```bash
+openstack hardware get <hardware_uuid>
+```
+
+```bash
+openstack hardware get <hardware_name>
+```
+
+### Set properties and name of an existing hardware item.
+
+```bash
+openstack hardware set <hardware_uuid> --name <new_hardware_name> --property <property_name>=<new_property_value>
+```
+
+Sets new name and property for the item `<hardware_uuid>`
+
+```bash
+openstack hardware set <hardware_name> --property <property_name>=<new_property_value>
+```
+
+Sets property for the item `<hardware_name`
+
+### Unset properties of an existing hardware item.
+
+```bash
+openstack hardware unset <hardware_uuid> --property <property_name>
+```
+
+Unsets property `<property_name>` for the item `<hardware_uuid`
+
+```bash
+openstack hardware update <hardware_name> --property <property_name>=<new_property_value>
+```
+
+Unsets property `<property_name>` for the item `<hardware_name>`

python_doniclient-1.0.4/README.md

@@ -0,0 +1,90 @@
+# ChameleonCloud Python Doniclient CLI
+
+![ChameleonCloud Logo](https://www.chameleoncloud.org/static/images/logo.png)
+
+Welcome to the ChameleonCloud Python Doniclient CLI repository! This command-line interface (CLI) provides a convenient way to interact with ChameleonCloud's Doni hardware inventory project, enabling you to manage and automate various hardware-related tasks.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Authentication](#authentication)
+- [Usage](#usage)
+- [Testing](#testing)
+- [Contributing](#contributing)
+
+## Installation
+
+You can install the ChameleonCloud Python Doniclient CLI using pip:
+
+```bash
+pip install python-doniclient
+```
+
+### Cython sources issue
+if you encounter an error message citing cython sources, please run the following to downgrade cython to a compatible version and use PyYaml 6.0+
+```pip install "cython<3.0.0"```
+
+## Authentication
+Environment variables are the primary authentication method. Please refer to the [documentation on OpenRC scripts](https://chameleoncloud.readthedocs.io/en/latest/technical/cli.html#the-openstack-rc-script)  to learn more about how to download and source your authentication credentials for the CLI;
+
+## Usage
+To use the CLI, you can run the `openstack hardware` command followed by the desired subcommand. `openstack hardware --help` shows all the subcommands available. Here's a basic usage examples:
+
+### List all hardware in the Doni database.
+
+```bash
+openstack hardware list
+```
+
+Options:
+
+- --all: List hardware from all owners (requires admin rights).
+- --long: Include all columns in the output.
+- --worker-type <worker_type>: Filter by worker type.
+- --worker-state <worker_state>: Filter by worker state (choices: PENDING, IN_PROGRESS, ERROR, STEADY).
+
+For more details on specific commands and their options use --help or -h
+
+### Create hardware in the Doni database
+
+```bash
+openstack hardware create --name <hardware_name> --hardware-type <hardware_type> --property <property_name>=<property_value>
+```
+
+### List specific hardware item in Doni using name or uuid.
+
+```bash
+openstack hardware get <hardware_uuid>
+```
+
+```bash
+openstack hardware get <hardware_name>
+```
+
+### Set properties and name of an existing hardware item.
+
+```bash
+openstack hardware set <hardware_uuid> --name <new_hardware_name> --property <property_name>=<new_property_value>
+```
+
+Sets new name and property for the item `<hardware_uuid>`
+
+```bash
+openstack hardware set <hardware_name> --property <property_name>=<new_property_value>
+```
+
+Sets property for the item `<hardware_name`
+
+### Unset properties of an existing hardware item.
+
+```bash
+openstack hardware unset <hardware_uuid> --property <property_name>
+```
+
+Unsets property `<property_name>` for the item `<hardware_uuid`
+
+```bash
+openstack hardware update <hardware_name> --property <property_name>=<new_property_value>
+```
+
+Unsets property `<property_name>` for the item `<hardware_name>`

{python-doniclient-1.0.3 → python_doniclient-1.0.4}/doniclient/osc/cli.py

@@ -13,6 +13,7 @@ from osc_lib.command import command
 from doniclient.osc.common import (
     BaseParser,
     ExpandDotNotation,
+    ExpandDotNotationAndStoreTrue,
     HardwarePatchCommand,
     conditional_action,
 )
@@ -40,32 +41,98 @@ class ListHardware(BaseParser, command.Lister):
             help="Include all columns.",
             action="store_true",
         )
+        parser.add_argument(
+            "--worker-type",
+            metavar="<worker_type>",
+            help="Filter by worker type",
+            required=False,
+            default="",
+        )
+        parser.add_argument(
+            "--worker-state",
+            help="Filter by worker state",
+            choices=["PENDING", "IN_PROGRESS", "ERROR", "STEADY"],
+            required=False,
+            default="",
+        )
         return parser
 
+    def extract_workers_state(self, workers):
+        # Extract worker types and their corresponding states and last errors from workers list
+        worker_details = {}
+        for worker in workers:
+            worker_type = worker.get("worker_type")
+            state = worker.get("state")
+            last_error = worker.get("state_details", {}).get("last_error")
+            if worker_type and (state or last_error):
+                if worker_type not in worker_details:
+                    worker_details[worker_type] = {}
+                if state:
+                    worker_details[worker_type]["state"] = state
+                if last_error:
+                    worker_details[worker_type]["last_error"] = last_error
+        return worker_details
+
     def take_action(self, parsed_args):
-        """List all hw items in Doni."""
+        """List all hardware items in Doni."""
+
         hw_client = self.app.client_manager.inventory
         columns = res_fields.HARDWARE_RESOURCE.fields
-        labels = res_fields.HARDWARE_RESOURCE.labels
+        labels = list(res_fields.HARDWARE_RESOURCE.labels)  # Convert tuple to list
 
         if parsed_args.long:
             columns = res_fields.HARDWARE_DETAILED_RESOURCE.fields
-            labels = res_fields.HARDWARE_DETAILED_RESOURCE.labels
+            labels = list(
+                res_fields.HARDWARE_DETAILED_RESOURCE.labels
+            )  # Convert tuple to list
 
+        # Fetch hardware data based on --all option
         if parsed_args.all:
             data = hw_client.export()
         else:
             data = hw_client.list()
 
-        return (
-            labels,
-            (
-                oscutils.get_dict_properties(
-                    s, columns, formatters={"Properties": oscutils.format_dict}
-                )
-                for s in data
-            ),
-        )
+        worker_types = []
+        output_data = []
+
+        # Extract filter values for better readability
+        worker_type_filter = parsed_args.worker_type
+        worker_state_filter = parsed_args.worker_state
+
+        for hardware in data:
+            workers = hardware.get("workers", [])
+            worker_details = self.extract_workers_state(workers)
+
+            # Apply worker type and state filters
+            if (worker_type_filter and worker_type_filter not in worker_details) or (
+                worker_state_filter
+                and all(worker_state_filter != details["state"] for details in worker_details.values())
+            ):
+                continue
+
+            output_item = oscutils.get_dict_properties(hardware, columns)
+
+            # Apply combined worker type and state filter
+            if worker_type_filter and worker_state_filter:
+                details = worker_details.get(worker_type_filter, {})
+                if worker_state_filter not in details["state"]:
+                    continue
+
+            for worker_type, details in worker_details.items():
+                worker_state = details.get("state", "-")
+                worker_error = details.get("last_error", "-")
+                output_item = output_item + (worker_state,)
+                output_item = output_item + (worker_error,)
+
+                if worker_type not in worker_types:
+                    worker_types.append(worker_type)
+                    worker_types.append(worker_type + " last error")
+
+            output_data.append(output_item)
+
+        labels += worker_types  # Add worker types to labels list
+        return labels, output_data
+
 
 
 class GetHardware(BaseParser, command.ShowOne):
@@ -93,7 +160,13 @@ class DeleteHardware(BaseParser):
     def take_action(self, parsed_args):
         hw_client = self.app.client_manager.inventory
         try:
-            hw_client.delete(parsed_args.uuid)
+            data = oscutils.find_resource(hw_client, parsed_args.uuid)
+        except HttpError as ex:
+            LOG.error(ex.response.text)
+            raise ex
+        uuid = data["uuid"]
+        try:
+            hw_client.delete(uuid)
         except HttpError as ex:
             LOG.error(ex.response.text)
             raise ex
@@ -107,15 +180,20 @@ class SyncHardware(BaseParser):
     def take_action(self, parsed_args):
         hw_client = self.app.client_manager.inventory
         try:
-            hw_client.sync(parsed_args.uuid)
+            data = oscutils.find_resource(hw_client, parsed_args.uuid)
+        except HttpError as ex:
+            LOG.error(ex.response.text)
+            raise ex
+        uuid = data["uuid"]
+        try:
+            hw_client.sync(uuid)
         except HttpError as ex:
             LOG.error(ex.response.text)
             raise ex
 
 
-def _add_prop_flag_group(parser, hardware_type, prop_flags):
+def _add_prop_flag_group(parser, hardware_type, prop_flags, prog_name):
     """Register a mapping of flags for corresponding hardware properties.
-
     Args:
         parser (argparse.Parser): the parent parser
         group_name (str): the name of the new argument grouping. This is just used
@@ -124,21 +202,70 @@ def _add_prop_flag_group(parser, hardware_type, prop_flags):
             containing information about how the flag should be displayed and parsed.
             Importantly, the property name MUST match some field on the ``properties``
             dict on the target hardware type.
+        prog_name (str): command executed (openstack hardware <set/unset>)
     """
     # Only store this flag in the resulting args if the hardware_type is in effect.
     condition_fn = lambda args: args.hardware_type == hardware_type
     group = parser.add_argument_group(f"{hardware_type} properties")
     for prop_name, flag in prop_flags.items():
+        argument_params = {}
+        argument_params["type"] = flag.type
+        argument_params["default"] = flag.default
+        argument_params["metavar"] = f"<{flag.flag}>"
+        argument_params["dest"] = f"properties.{prop_name}"
+        argument_params["action"] = conditional_action(ExpandDotNotation, condition_fn)
+        if 'unset' in prog_name:
+            argument_params["nargs"] = 0
+            argument_params["type"] = None
+            argument_params["default"] = None
+            argument_params["metavar"] = None
+            argument_params["action"] = conditional_action(ExpandDotNotationAndStoreTrue, condition_fn)
         group.add_argument(
             f"--{flag.flag}",
-            type=flag.type,
-            default=flag.default,
-            metavar=f"<{flag.flag}>",
-            dest=f"properties.{prop_name}",
-            action=conditional_action(ExpandDotNotation, condition_fn),
+            **argument_params
         )
 
 
+class HardwarePropertyFlags:
+    baremetal_property_flags = {
+        "management_address": PropertyFlag("management_address", str, None),
+        "ipmi_username": PropertyFlag("ipmi_username", str, None),
+        "ipmi_password": PropertyFlag("ipmi_password", str, None),
+        "ipmi_terminal_port": PropertyFlag("ipmi_terminal_port", int, None),
+        "baremetal_deploy_kernel_image": PropertyFlag(
+            "deploy_kernel", str, None
+        ),
+        "baremetal_deploy_ramdisk_image": PropertyFlag(
+            "deploy_ramdisk", str, None
+        ),
+        # FIXME(jason): why is the flag named ironic_?
+        "baremetal_driver": PropertyFlag("ironic_driver", str, None),
+        "baremetal_resource_class": PropertyFlag(
+            "resource_class", str, "baremetal"
+        ),
+        "baremetal_capabilities": PropertyFlag(
+            "capabilities", json.loads, None
+        ),
+        "cpu_arch": PropertyFlag("cpu_arch", str, "x86_64"),
+        "node_type": PropertyFlag("blazar_node_type", str, None),
+        "su_factor": PropertyFlag("blazar_su_factor", float, 1.0),
+        "placement": PropertyFlag("placement", json.loads, None),
+        "interfaces": PropertyFlag("interfaces", json.loads, {}),
+    }
+    device_property_flags = {
+        "machine_name": PropertyFlag("machine-name", str, None),
+        "contact_email": PropertyFlag("contact-email", str, None),
+        "channels": PropertyFlag("channels", json.loads, None),
+        "application_credential_id": PropertyFlag(
+            "application-credential-id", str, None
+        ),
+        "application_credential_secret": PropertyFlag(
+            "application-credential-secret", str, None
+        ),
+        "local_egress": PropertyFlag("local-egress", str, None),
+    }
+
+
 class CreateOrUpdateParser(BaseParser):
     def get_parser(self, prog_name):
         parser = super().get_parser(prog_name)
@@ -162,48 +289,15 @@ class CreateOrUpdateParser(BaseParser):
         _add_prop_flag_group(
             parser,
             "baremetal",
-            {
-                "mgmt_addr": PropertyFlag("mgmt_addr", str, None),
-                "ipmi_username": PropertyFlag("ipmi_username", str, None),
-                "ipmi_password": PropertyFlag("ipmi_password", str, None),
-                "ipmi_terminal_port": PropertyFlag("ipmi_terminal_port", int, None),
-                "baremetal_deploy_kernel_image": PropertyFlag(
-                    "deploy_kernel", str, None
-                ),
-                "baremetal_deploy_ramdisk_image": PropertyFlag(
-                    "deploy_ramdisk", str, None
-                ),
-                # FIXME(jason): why is the flag named ironic_?
-                "baremetal_driver": PropertyFlag("ironic_driver", str, None),
-                "baremetal_resource_class": PropertyFlag(
-                    "resource_class", str, "baremetal"
-                ),
-                "baremetal_capabilities": PropertyFlag(
-                    "capabilities", json.loads, None
-                ),
-                "cpu_arch": PropertyFlag("cpu_arch", str, "x86_64"),
-                "node_type": PropertyFlag("blazar_node_type", str, None),
-                "su_factor": PropertyFlag("blazar_su_factor", float, 1.0),
-                "placement": PropertyFlag("placement", json.loads, None),
-                "interfaces": PropertyFlag("interfaces", json.loads, {}),
-            },
+            HardwarePropertyFlags.baremetal_property_flags,
+            prog_name
         )
 
         _add_prop_flag_group(
             parser,
             "device",
-            {
-                "machine_name": PropertyFlag("machine-name", str, None),
-                "contact_email": PropertyFlag("contact-email", str, None),
-                "channels": PropertyFlag("channels", json.loads, None),
-                "application_credential_id": PropertyFlag(
-                    "application-credential-id", str, None
-                ),
-                "application_credential_secret": PropertyFlag(
-                    "application-credential-secret", str, None
-                ),
-                "local_egress": PropertyFlag("local-egress", str, None),
-            },
+            HardwarePropertyFlags.device_property_flags,
+            prog_name
         )
 
         return parser
@@ -284,6 +378,21 @@ class UpdateHardware(CreateOrUpdateParser, HardwarePatchCommand):
 
         return patch
 
+    def take_action(self, parsed_args):
+        hw_client = self.app.client_manager.inventory
+        try:
+            data = oscutils.find_resource(hw_client, parsed_args.uuid)
+        except HttpError as ex:
+            LOG.error(ex.response.text)
+            raise ex
+        uuid = data["uuid"]
+        patch = self.get_patch(parsed_args)
+        try:
+            hw_client.update(uuid, patch)
+        except HttpError as ex:
+            LOG.error(ex.response.text)
+            raise ex
+
 
 class ImportHardware(BaseParser):
     def get_parser(self, prog_name):
@@ -313,3 +422,29 @@ class ImportHardware(BaseParser):
                             raise ex
                     else:
                         LOG.debug(data)
+
+
+class UnsetHardware(UpdateHardware):
+    """Unset properties of existing hardware item."""
+
+    needs_uuid = True
+
+    def get_patch(self, parsed_args):
+        patch = []
+
+        field_map = {
+            "name": "name",
+        }
+
+        for key, val in field_map.items():
+            arg = getattr(parsed_args, key, None)
+            if arg:
+                patch.append({"op": "remove", "path": f"/{val}", "value": arg})
+
+        try:
+            for key, val in parsed_args.properties.items():
+                patch.append({"op": "remove", "path": f"/properties/{key}", "value": val})
+        except AttributeError:
+            pass
+
+        return patch

{python-doniclient-1.0.3 → python_doniclient-1.0.4}/doniclient/osc/common.py

@@ -63,6 +63,17 @@ class ExpandDotNotation(argparse.Action):
         getattr(namespace, group).update({dest: values})
 
 
+class ExpandDotNotationAndStoreTrue(argparse.Action):
+    """Set property based on dest.key."""
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        group, dest = self.dest.split(".", 2)
+
+        if not hasattr(namespace, group):
+            setattr(namespace, group, {})
+        getattr(namespace, group).update({dest: True})
+
+
 class BaseParser(command.Command):
     """Base Parser for use with Doni commands.
 

{python-doniclient-1.0.3 → python_doniclient-1.0.4}/doniclient/v1/resource_fields.py

@@ -55,7 +55,6 @@ HARDWARE_RESOURCE = Resource(
     [
         "uuid",
         "name",
-        "properties",
     ]
 )
 

python_doniclient-1.0.4/pyproject.toml

@@ -0,0 +1,60 @@
+[project]
+name = "python-doniclient"
+version = "1.0.4"
+description = "This is a plugin for the openstack commandline client, to enable support for the Doni hardware inventory project"
+authors = [{ name = "Chameleon Cloud", email = "contact@chameleoncloud.org" }]
+requires-python = ">=3.9"
+readme = "README.md"
+license = "Apache-2.0"
+classifiers = [
+    "Environment :: OpenStack",
+    "Intended Audience :: Information Technology",
+    "Intended Audience :: System Administrators",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+
+]
+dependencies = [
+    "osc-lib",
+    "python-dateutil",
+    "PyYAML>=5.4.1",
+    "keystoneauth1",
+]
+
+[project.urls]
+Repository = "https://github.com/ChameleonCloud/python-doniclient"
+
+[project.entry-points."openstack.cli.extension"]
+inventory = "doniclient.osc.plugin"
+
+[project.entry-points."openstack.inventory.v1"]
+hardware_list = "doniclient.osc.cli:ListHardware"
+hardware_import = "doniclient.osc.cli:ImportHardware"
+hardware_show = "doniclient.osc.cli:GetHardware"
+hardware_create = "doniclient.osc.cli:CreateHardware"
+hardware_set = "doniclient.osc.cli:UpdateHardware"
+hardware_unset = "doniclient.osc.cli:UnsetHardware"
+hardware_delete = "doniclient.osc.cli:DeleteHardware"
+hardware_sync = "doniclient.osc.cli:SyncHardware"
+hardware_availability_list = "doniclient.osc.availability:ListHardwareAvailability"
+hardware_availability_set = "doniclient.osc.availability:UpdateHardwareAvailability"
+hardware_availability_add = "doniclient.osc.availability:AddHardwareAvailability"
+hardware_availability_remove = "doniclient.osc.availability:RemoveHardwareAvailability"
+
+
+[dependency-groups]
+dev = [
+    "oslotest",
+    "python-openstackclient",
+    "ruff",
+    "stestr",
+]
+
+[build-system]
+requires = ["setuptools>=64"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+include = ["doniclient*"]
+exclude = ["doniclient.tests*"]

python_doniclient-1.0.4/python_doniclient.egg-info/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: python-doniclient
+Version: 1.0.4
+Summary: This is a plugin for the openstack commandline client, to enable support for the Doni hardware inventory project
+Author-email: Chameleon Cloud <contact@chameleoncloud.org>
+License-Expression: Apache-2.0
+Project-URL: Repository, https://github.com/ChameleonCloud/python-doniclient
+Classifier: Environment :: OpenStack
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: System Administrators
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: osc-lib
+Requires-Dist: python-dateutil
+Requires-Dist: PyYAML>=5.4.1
+Requires-Dist: keystoneauth1
+
+# ChameleonCloud Python Doniclient CLI
+
+![ChameleonCloud Logo](https://www.chameleoncloud.org/static/images/logo.png)
+
+Welcome to the ChameleonCloud Python Doniclient CLI repository! This command-line interface (CLI) provides a convenient way to interact with ChameleonCloud's Doni hardware inventory project, enabling you to manage and automate various hardware-related tasks.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Authentication](#authentication)
+- [Usage](#usage)
+- [Testing](#testing)
+- [Contributing](#contributing)
+
+## Installation
+
+You can install the ChameleonCloud Python Doniclient CLI using pip:
+
+```bash
+pip install python-doniclient
+```
+
+### Cython sources issue
+if you encounter an error message citing cython sources, please run the following to downgrade cython to a compatible version and use PyYaml 6.0+
+```pip install "cython<3.0.0"```
+
+## Authentication
+Environment variables are the primary authentication method. Please refer to the [documentation on OpenRC scripts](https://chameleoncloud.readthedocs.io/en/latest/technical/cli.html#the-openstack-rc-script)  to learn more about how to download and source your authentication credentials for the CLI;
+
+## Usage
+To use the CLI, you can run the `openstack hardware` command followed by the desired subcommand. `openstack hardware --help` shows all the subcommands available. Here's a basic usage examples:
+
+### List all hardware in the Doni database.
+
+```bash
+openstack hardware list
+```
+
+Options:
+
+- --all: List hardware from all owners (requires admin rights).
+- --long: Include all columns in the output.
+- --worker-type <worker_type>: Filter by worker type.
+- --worker-state <worker_state>: Filter by worker state (choices: PENDING, IN_PROGRESS, ERROR, STEADY).
+
+For more details on specific commands and their options use --help or -h
+
+### Create hardware in the Doni database
+
+```bash
+openstack hardware create --name <hardware_name> --hardware-type <hardware_type> --property <property_name>=<property_value>
+```
+
+### List specific hardware item in Doni using name or uuid.
+
+```bash
+openstack hardware get <hardware_uuid>
+```
+
+```bash
+openstack hardware get <hardware_name>
+```
+
+### Set properties and name of an existing hardware item.
+
+```bash
+openstack hardware set <hardware_uuid> --name <new_hardware_name> --property <property_name>=<new_property_value>
+```
+
+Sets new name and property for the item `<hardware_uuid>`
+
+```bash
+openstack hardware set <hardware_name> --property <property_name>=<new_property_value>
+```
+
+Sets property for the item `<hardware_name`
+
+### Unset properties of an existing hardware item.
+
+```bash
+openstack hardware unset <hardware_uuid> --property <property_name>
+```
+
+Unsets property `<property_name>` for the item `<hardware_uuid`
+
+```bash
+openstack hardware update <hardware_name> --property <property_name>=<new_property_value>
+```
+
+Unsets property `<property_name>` for the item `<hardware_name>`

python_doniclient-1.0.4/python_doniclient.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+README.md
+pyproject.toml
+doniclient/__init__.py
+doniclient/osc/__init__.py
+doniclient/osc/availability.py
+doniclient/osc/cli.py
+doniclient/osc/common.py
+doniclient/osc/plugin.py
+doniclient/v1/client.py
+doniclient/v1/resource_fields.py
+python_doniclient.egg-info/PKG-INFO
+python_doniclient.egg-info/SOURCES.txt
+python_doniclient.egg-info/dependency_links.txt
+python_doniclient.egg-info/entry_points.txt
+python_doniclient.egg-info/requires.txt
+python_doniclient.egg-info/top_level.txt

python_doniclient-1.0.4/python_doniclient.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

python_doniclient-1.0.4/python_doniclient.egg-info/entry_points.txt

@@ -0,0 +1,16 @@
+[openstack.cli.extension]
+inventory = doniclient.osc.plugin
+
+[openstack.inventory.v1]
+hardware_availability_add = doniclient.osc.availability:AddHardwareAvailability
+hardware_availability_list = doniclient.osc.availability:ListHardwareAvailability
+hardware_availability_remove = doniclient.osc.availability:RemoveHardwareAvailability
+hardware_availability_set = doniclient.osc.availability:UpdateHardwareAvailability
+hardware_create = doniclient.osc.cli:CreateHardware
+hardware_delete = doniclient.osc.cli:DeleteHardware
+hardware_import = doniclient.osc.cli:ImportHardware
+hardware_list = doniclient.osc.cli:ListHardware
+hardware_set = doniclient.osc.cli:UpdateHardware
+hardware_show = doniclient.osc.cli:GetHardware
+hardware_sync = doniclient.osc.cli:SyncHardware
+hardware_unset = doniclient.osc.cli:UnsetHardware

python_doniclient-1.0.4/python_doniclient.egg-info/requires.txt

@@ -0,0 +1,4 @@
+osc-lib
+python-dateutil
+PyYAML>=5.4.1
+keystoneauth1

python_doniclient-1.0.4/python_doniclient.egg-info/top_level.txt

@@ -0,0 +1 @@
+doniclient

python_doniclient-1.0.4/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

python-doniclient-1.0.3/PKG-INFO

@@ -1,33 +0,0 @@
-Metadata-Version: 2.1
-Name: python-doniclient
-Version: 1.0.3
-Summary: This is a plugin for the openstack commandline client, to enable support for the Doni hardware inventory project
-Home-page: https://github.com/ChameleonCloud/python-doniclient
-License: Apache-2.0
-Author: Chameleon Cloud
-Author-email: contact@chameleoncloud.org
-Requires-Python: >=3.7,<4.0
-Classifier: Environment :: OpenStack
-Classifier: Intended Audience :: Information Technology
-Classifier: Intended Audience :: System Administrators
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Operating System :: POSIX :: Linux
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Requires-Dist: PyYAML (<=5.4.1)
-Requires-Dist: keystoneauth1 (<=4.4.0)
-Requires-Dist: osc-lib (<=2.4.2)
-Requires-Dist: python-dateutil (<=2.8.2)
-Requires-Dist: python-openstackclient[cli] (<=5.6.0)
-Project-URL: Repository, https://github.com/ChameleonCloud/python-doniclient
-Description-Content-Type: text/markdown
-
-# python-doniclient
-
-Client for Chameleon Registration Service
-
-
-

python-doniclient-1.0.3/README.md

@@ -1,5 +0,0 @@
-# python-doniclient
-
-Client for Chameleon Registration Service
-
-

python-doniclient-1.0.3/doniclient/tests/osc/fakes.py

@@ -1,57 +0,0 @@
-"""Define fake objects for Doni CLI tests."""
-
-import copy
-import datetime
-import uuid
-from unittest import mock
-
-from openstackclient.tests.unit import fakes, utils
-
-hardware_uuid = uuid.uuid4().hex
-hardware_name = "fake name"
-hardware_project_id = uuid.uuid4().hex
-hardware_created_at = datetime.datetime.utcnow().isoformat()
-hardware_updated_at = datetime.datetime.utcnow().isoformat()
-hardware_baremetal_type = "baremetal"
-
-
-class FakeHardware(object):
-    @staticmethod
-    def create_one_hardware(attrs=None):
-        """Create a fake hw item."""
-        attrs = attrs or {}
-
-        hw_info = {
-            "created_at": hardware_created_at,
-            "hardware_type": hardware_baremetal_type,
-            "name": hardware_name,
-            "project_id": hardware_project_id,
-            "properties": {},
-            "updated_at": hardware_updated_at,
-            "uuid": hardware_uuid,
-            "workers": [],
-        }
-
-        hw_info.update(attrs)
-        # TODO: client currently returns Dicts, not Resource objects.
-        # hw_item = fakes.FakeResource(info=copy.deepcopy(hw_info), loaded=True)
-        return hw_info
-
-
-class FakeHardwareClient(object):
-    def __init__(self, **kwargs) -> None:
-        self.hardware = mock.Mock()
-        self.hardware.resource_class = fakes.FakeResource(None, {})
-
-
-class TestHardware(utils.TestCommand):
-    def setUp(self):
-        super(TestHardware, self).setUp()
-
-        self.app.client_manager.auth_ref = mock.Mock(auth_token="TOKEN")
-        self.app.client_manager.inventory = mock.Mock()
-
-
-class FakeHardwareResource(fakes.FakeResource):
-    def get_keys(self):
-        return {"property": "value"}

python-doniclient-1.0.3/doniclient/tests/osc/test_hardware.py

@@ -1,168 +0,0 @@
-from doniclient.osc import cli as hardware_cli
-from doniclient.tests.osc import fakes as hardware_fakes
-
-FAKE_HARDWARE_UUID = hardware_fakes.hardware_uuid
-
-UPDATE_PARAMS = [
-    (
-        "baremetal",
-        "--mgmt_addr",
-        "mgmt_addr",
-        "/properties/mgmt_addr",
-        "fake-mgmt_addr",
-    ),
-    (
-        "device",
-        "--machine-name",
-        "machine_name",
-        "/properties/machine_name",
-        "jetson-nano",
-    ),
-    (
-        "device",
-        "--contact-email",
-        "contact_email",
-        "/properties/contact_email",
-        "test@foo.bar",
-    ),
-    ("device", "--local-egress", "local_egress", "/properties/local_egress", "allow"),
-]
-
-
-class TestHardware(hardware_fakes.TestHardware):
-    def setUp(self):
-        super(TestHardware, self).setUp()
-
-        # Get a shortcut to the baremetal manager mock
-        self.hardware_mock = self.app.client_manager.inventory
-        self.hardware_mock.reset_mock()
-
-
-class TestHardwareShow(TestHardware):
-    def setUp(self):
-        super().setUp()
-
-        self.hardware_mock.get_by_uuid.return_value = (
-            hardware_fakes.FakeHardware.create_one_hardware()
-        )
-
-        self.cmd = hardware_cli.GetHardware(self.app, None)
-
-    def test_hardware_show(self):
-        arglist = [FAKE_HARDWARE_UUID]
-        verifylist = []
-
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # DisplayCommandBase.take_action() returns two tuples
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        args = [FAKE_HARDWARE_UUID]
-
-        self.hardware_mock.get_by_uuid.assert_called_with(*args)
-
-        collist = (
-            "created_at",
-            "hardware_type",
-            "name",
-            "project_id",
-            "properties",
-            "updated_at",
-            "uuid",
-            "workers",
-        )
-        self.assertEqual(collist, columns)
-
-        datalist = (
-            hardware_fakes.hardware_created_at,
-            hardware_fakes.hardware_baremetal_type,
-            hardware_fakes.hardware_name,
-            hardware_fakes.hardware_project_id,
-            {},
-            hardware_fakes.hardware_updated_at,
-            hardware_fakes.hardware_uuid,
-            [],
-        )
-        self.assertEqual(datalist, tuple(data))
-
-
-class TestHardwareList(TestHardware):
-    def setUp(self):
-        super().setUp()
-
-        self.hardware_mock.list.return_value = list(
-            hardware_fakes.FakeHardware.create_one_hardware()
-        )
-
-        self.cmd = hardware_cli.ListHardware(self.app, None)
-
-    def test_hardware_list(self):
-        arglist = []
-        verifylist = []
-
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # DisplayCommandBase.take_action() returns two tuples
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        args = []
-
-        self.hardware_mock.list.assert_called_with(*args)
-
-
-class TestHardwareCreate(TestHardware):
-    def setUp(self):
-        super().setUp()
-        self.cmd = hardware_cli.CreateHardware(self.app, None)
-
-
-class TestHardwareDelete(TestHardware):
-    def setUp(self):
-        super().setUp()
-        self.cmd = hardware_cli.DeleteHardware(self.app, None)
-
-
-class TestHardwareSetMeta(type):
-    """Metaclass to generate list of test cases."""
-
-    def __new__(mcs, name, bases, dict):
-        def gen_test(hw_type, arg, prop, path, value):
-            def test(self):
-                self.hardware_mock.update.return_value = (
-                    hardware_fakes.FakeHardware.create_one_hardware()
-                )
-                arglist = [
-                    FAKE_HARDWARE_UUID,
-                    "--hardware_type",
-                    hw_type,
-                    arg,
-                    value,
-                ]
-                parsed_args = self.check_parser(self.cmd, arglist, [])
-                assert parsed_args.properties == {prop: value}
-
-                self.cmd.take_action(parsed_args)
-                self.hardware_mock.update.assert_called_with(
-                    FAKE_HARDWARE_UUID, [{"op": "add", "path": path, "value": value}]
-                )
-
-            return test
-
-        for hw_type, arg, prop, path, value in UPDATE_PARAMS:
-            test_name = "test_device_update_%s" % prop
-            dict[test_name] = gen_test(hw_type, arg, prop, path, value)
-        return type.__new__(mcs, name, bases, dict)
-
-
-class TestHardwareSet(TestHardware, metaclass=TestHardwareSetMeta):
-    def setUp(self):
-        super().setUp()
-        self.cmd = hardware_cli.UpdateHardware(self.app, None)
-
-
-class TestHardwareSync(TestHardware):
-    def setUp(self):
-        super().setUp()
-        self.cmd = hardware_cli.SyncHardware(self.app, None)

python-doniclient-1.0.3/pyproject.toml

@@ -1,71 +0,0 @@
-[tool.black]
-# Set line length explicitly.
-# See https://black.readthedocs.io/en/stable/the_black_code_style.html#line-length for more details
-line-length = 88
-
-[tool.pytest.ini_options]
-log_cli = true
-log_cli_level = "INFO"
-log_cli_format = "%(asctime)s [%(levelname)8s] %(message)s (%(filename)s:%(lineno)s)"
-log_cli_date_format = "%Y-%m-%d %H:%M:%S"
-filterwarnings = ["ignore::DeprecationWarning"]
-
-[tool.isort]
-known_first_party = "doniclient"
-
-[tool.poetry]
-name = "python-doniclient"
-version = "1.0.3"
-description = "This is a plugin for the openstack commandline client, to enable support for the Doni hardware inventory project"
-license = "Apache-2.0"
-authors = ["Chameleon Cloud <contact@chameleoncloud.org>"]
-readme = "README.md"
-repository = "https://github.com/ChameleonCloud/python-doniclient"
-
-classifiers = [
-    "Environment :: OpenStack",
-    "Intended Audience :: Information Technology",
-    "Intended Audience :: System Administrators",
-    "Operating System :: POSIX :: Linux",
-]
-
-packages = [{ include = "doniclient" }]
-
-[tool.poetry.dependencies]
-python = "^3.7"
-osc-lib = "<=2.4.2"
-python-openstackclient = { version = "<=5.6.0", extras = ["cli"] }
-python-dateutil = "<=2.8.2"
-PyYAML = "<=5.4.1"
-keystoneauth1 = "<=4.4.0"
-
-[tool.poetry.dev-dependencies]
-pytest = "^6.2"
-black = "^22.10"
-flake8 = "^3.9.0"
-flake8-bugbear = "^21.4.1"
-pytest-mock = "^3.5.1"
-isort = "^5.8.0"
-pydocstyle = "^6.0.0"
-oslotest = "^4.4.1"
-stestr = "^3.2.1"
-
-[build-system]
-requires = ["poetry-core>=1.0.0"]
-build-backend = "poetry.core.masonry.api"
-
-[tool.poetry.plugins."openstack.cli.extension"]
-inventory = "doniclient.osc.plugin"
-
-[tool.poetry.plugins."openstack.inventory.v1"]
-hardware_list = "doniclient.osc.cli:ListHardware"
-hardware_import = "doniclient.osc.cli:ImportHardware"
-hardware_show = "doniclient.osc.cli:GetHardware"
-hardware_create = "doniclient.osc.cli:CreateHardware"
-hardware_set = "doniclient.osc.cli:UpdateHardware"
-hardware_delete = "doniclient.osc.cli:DeleteHardware"
-hardware_sync = "doniclient.osc.cli:SyncHardware"
-hardware_availability_list = "doniclient.osc.availability:ListHardwareAvailability"
-hardware_availability_set = "doniclient.osc.availability:UpdateHardwareAvailability"
-hardware_availability_add = "doniclient.osc.availability:AddHardwareAvailability"
-hardware_availability_remove = "doniclient.osc.availability:RemoveHardwareAvailability"

python-doniclient-1.0.3/setup.py

@@ -1,61 +0,0 @@
-# -*- coding: utf-8 -*-
-from setuptools import setup
-
-packages = \
-['doniclient',
- 'doniclient.osc',
- 'doniclient.tests',
- 'doniclient.tests.osc',
- 'doniclient.tests.v1',
- 'doniclient.v1']
-
-package_data = \
-{'': ['*']}
-
-install_requires = \
-['PyYAML<=5.4.1',
- 'keystoneauth1<=4.4.0',
- 'osc-lib<=2.4.2',
- 'python-dateutil<=2.8.2',
- 'python-openstackclient[cli]<=5.6.0']
-
-entry_points = \
-{'openstack.cli.extension': ['inventory = doniclient.osc.plugin'],
- 'openstack.inventory.v1': ['hardware_availability_add = '
-                            'doniclient.osc.availability:AddHardwareAvailability',
-                            'hardware_availability_list = '
-                            'doniclient.osc.availability:ListHardwareAvailability',
-                            'hardware_availability_remove = '
-                            'doniclient.osc.availability:RemoveHardwareAvailability',
-                            'hardware_availability_set = '
-                            'doniclient.osc.availability:UpdateHardwareAvailability',
-                            'hardware_create = '
-                            'doniclient.osc.cli:CreateHardware',
-                            'hardware_delete = '
-                            'doniclient.osc.cli:DeleteHardware',
-                            'hardware_import = '
-                            'doniclient.osc.cli:ImportHardware',
-                            'hardware_list = doniclient.osc.cli:ListHardware',
-                            'hardware_set = doniclient.osc.cli:UpdateHardware',
-                            'hardware_show = doniclient.osc.cli:GetHardware',
-                            'hardware_sync = doniclient.osc.cli:SyncHardware']}
-
-setup_kwargs = {
-    'name': 'python-doniclient',
-    'version': '1.0.3',
-    'description': 'This is a plugin for the openstack commandline client, to enable support for the Doni hardware inventory project',
-    'long_description': '# python-doniclient\n\nClient for Chameleon Registration Service\n\n\n',
-    'author': 'Chameleon Cloud',
-    'author_email': 'contact@chameleoncloud.org',
-    'maintainer': None,
-    'maintainer_email': None,
-    'url': 'https://github.com/ChameleonCloud/python-doniclient',
-    'packages': packages,
-    'package_data': package_data,
-    'install_requires': install_requires,
-    'entry_points': entry_points,
-    'python_requires': '>=3.7,<4.0',
-}
-
-
-setup(**setup_kwargs)