Hv placement switch

openstackquery/__init__.py

@@ -7,6 +7,7 @@
     ProjectQuery,
     ImageQuery,
     HypervisorQuery,
+    PlacementQuery,
 )
 
 # Create logger

openstackquery/api/query_objects.py

@@ -5,6 +5,7 @@
 from openstackquery.mappings.hypervisor_mapping import HypervisorMapping
 from openstackquery.mappings.image_mapping import ImageMapping
 from openstackquery.mappings.mapping_interface import MappingInterface
+from openstackquery.mappings.placement_mapping import PlacementMapping
 from openstackquery.mappings.project_mapping import ProjectMapping
 from openstackquery.mappings.server_mapping import ServerMapping
 from openstackquery.mappings.user_mapping import UserMapping
@@ -70,3 +71,10 @@
     Simple helper function to setup a query using a factory
     """
     return get_common(HypervisorMapping)
+
+
+def PlacementQuery() -> "QueryAPI":
+    """
+    Simple helper function to setup a query using a factory
+    """
+    return get_common(PlacementMapping)

openstackquery/enums/props/hypervisor_properties.py

@@ -12,21 +12,11 @@ class HypervisorProperties(PropEnum):
     An enum class for all hypervisor properties
     """
 
-    # HYPERVISOR_CURRENT_WORKLOAD = auto()
-    HYPERVISOR_DISK_FREE = auto()
-    HYPERVISOR_DISK_SIZE = auto()
-    HYPERVISOR_DISK_USED = auto()
     HYPERVISOR_ID = auto()
     HYPERVISOR_IP = auto()
-    HYPERVISOR_MEMORY_FREE = auto()
-    HYPERVISOR_MEMORY_SIZE = auto()
-    HYPERVISOR_MEMORY_USED = auto()
     HYPERVISOR_NAME = auto()
-    # HYPERVISOR_SERVER_COUNT = auto() # Deprecated, use server query
     HYPERVISOR_STATE = auto()
     HYPERVISOR_STATUS = auto()
-    HYPERVISOR_VCPUS = auto()
-    HYPERVISOR_VCPUS_USED = auto()
     HYPERVISOR_DISABLED_REASON = auto()
     HYPERVISOR_UPTIME_DAYS = auto()
 
@@ -36,33 +26,11 @@ def _get_aliases() -> Dict:
         A method that returns all valid string alias mappings
         """
         return {
-            # HypervisorProperties.HYPERVISOR_CURRENT_WORKLOAD: [
-            #     "current_workload",
-            #     "workload",
-            # ],
-            HypervisorProperties.HYPERVISOR_DISK_FREE: [
-                "local_disk_free",
-                "free_disk_gb",
-            ],
-            HypervisorProperties.HYPERVISOR_DISK_SIZE: ["local_disk_size", "local_gb"],
-            HypervisorProperties.HYPERVISOR_DISK_USED: [
-                "local_disk_used",
-                "local_gb_used",
-            ],
             HypervisorProperties.HYPERVISOR_ID: ["id", "uuid", "host_id"],
             HypervisorProperties.HYPERVISOR_IP: ["ip", "host_ip"],
-            HypervisorProperties.HYPERVISOR_MEMORY_FREE: ["memory_free", "free_ram_mb"],
-            HypervisorProperties.HYPERVISOR_MEMORY_SIZE: ["memory_size", "memory_mb"],
-            HypervisorProperties.HYPERVISOR_MEMORY_USED: [
-                "memory_used",
-                "memory_mb_used",
-            ],
             HypervisorProperties.HYPERVISOR_NAME: ["name", "host_name"],
-            # HypervisorProperties.HYPERVISOR_SERVER_COUNT: ["running_vms"],
             HypervisorProperties.HYPERVISOR_STATE: ["state"],
             HypervisorProperties.HYPERVISOR_STATUS: ["status"],
-            HypervisorProperties.HYPERVISOR_VCPUS: ["vcpus"],
-            HypervisorProperties.HYPERVISOR_VCPUS_USED: ["vcpus_used"],
             HypervisorProperties.HYPERVISOR_DISABLED_REASON: ["disabled_reason"],
             HypervisorProperties.HYPERVISOR_UPTIME_DAYS: ["uptime"],
         }
@@ -76,39 +44,12 @@ def get_prop_mapping(prop) -> Optional[PropFunc]:
         :param prop: A HypervisorProperty Enum for which a function may exist for
         """
         mapping = {
-            # HypervisorProperties.HYPERVISOR_CURRENT_WORKLOAD: lambda a: a[
-            #     "current_workload"
-            # ],
-            HypervisorProperties.HYPERVISOR_DISK_FREE: lambda a: a.resources["DISK_GB"][
-                "free"
-            ],
-            HypervisorProperties.HYPERVISOR_DISK_SIZE: lambda a: a.resources["DISK_GB"][
-                "total"
-            ],
-            HypervisorProperties.HYPERVISOR_DISK_USED: lambda a: a.resources["DISK_GB"][
-                "usage"
-            ],
             HypervisorProperties.HYPERVISOR_ID: lambda a: a["id"],
             HypervisorProperties.HYPERVISOR_IP: lambda a: a["host_ip"],
-            HypervisorProperties.HYPERVISOR_MEMORY_FREE: lambda a: a.resources[
-                "MEMORY_MB"
-            ]["free"],
-            HypervisorProperties.HYPERVISOR_MEMORY_SIZE: lambda a: a.resources[
-                "MEMORY_MB"
-            ]["total"],
-            HypervisorProperties.HYPERVISOR_MEMORY_USED: lambda a: a.resources[
-                "MEMORY_MB"
-            ]["usage"],
             HypervisorProperties.HYPERVISOR_NAME: lambda a: a["name"],
             # HypervisorProperties.HYPERVISOR_SERVER_COUNT: lambda a: a["runnning_vms"],
             HypervisorProperties.HYPERVISOR_STATE: lambda a: a["state"],
             HypervisorProperties.HYPERVISOR_STATUS: lambda a: a["status"],
-            HypervisorProperties.HYPERVISOR_VCPUS: lambda a: a.resources["VCPU"][
-                "total"
-            ],
-            HypervisorProperties.HYPERVISOR_VCPUS_USED: lambda a: a.resources["VCPU"][
-                "usage"
-            ],
             HypervisorProperties.HYPERVISOR_DISABLED_REASON: lambda a: a["service"][
                 "disabled_reason"
             ],

openstackquery/enums/props/placement_properties.py

@@ -0,0 +1,79 @@
+from enum import auto
+from typing import Dict, Optional
+
+from openstackquery.enums.props.prop_enum import PropEnum, PropFunc
+from openstackquery.exceptions.query_property_mapping_error import (
+    QueryPropertyMappingError,
+)
+
+
+class PlacementProperties(PropEnum):
+    """
+    An enum class for currently used placement properties
+    """
+
+    RESOURCE_PROVIDER_ID = auto()
+    RESOURCE_PROVIDER_NAME = auto()
+    VCPUS_USED = auto()
+    VCPUS_AVAIL = auto()
+    MEMORY_MB_USED = auto()
+    MEMORY_MB_AVAIL = auto()
+    DISK_GB_USED = auto()
+    DISK_GB_AVAIL = auto()
+
+    @staticmethod
+    def _get_aliases() -> Dict:
+        """
+        A method that returns all valid string alias mappings
+        """
+        return {
+            PlacementProperties.RESOURCE_PROVIDER_ID: [
+                "resource_provider_id",
+                "resource_provider_uuid",
+                "id",
+            ],
+            PlacementProperties.RESOURCE_PROVIDER_NAME: [
+                "resource_name",
+                "name",
+                "provider_name",
+            ],
+            PlacementProperties.VCPUS_USED: ["vcpus_used"],
+            PlacementProperties.VCPUS_AVAIL: ["vcpus_avail"],
+            PlacementProperties.MEMORY_MB_USED: ["memory_mb_used"],
+            PlacementProperties.MEMORY_MB_AVAIL: ["memory_mb_avail"],
+            PlacementProperties.DISK_GB_USED: ["disk_gb_used"],
+            PlacementProperties.DISK_GB_AVAIL: ["disk_gb_avail"],
+        }
+
+    @staticmethod
+    def get_prop_mapping(prop) -> Optional[PropFunc]:
+        """
+        Method that returns the property function if function mapping exists for a given Hypervisor Enum
+        how to get specified property from a ResourceProviderUsage object
+        :param prop: A HypervisorProperty Enum for which a function may exist for
+        """
+        mapping = {
+            PlacementProperties.RESOURCE_PROVIDER_ID: lambda a: a["id"],
+            PlacementProperties.RESOURCE_PROVIDER_NAME: lambda a: a["name"],
+            PlacementProperties.VCPUS_AVAIL: lambda a: a["vcpu_avail"],
+            PlacementProperties.MEMORY_MB_AVAIL: lambda a: a["memory_mb_avail"],
+            PlacementProperties.DISK_GB_AVAIL: lambda a: a["disk_gb_avail"],
+            PlacementProperties.VCPUS_USED: lambda a: a["vcpu_used"],
+            PlacementProperties.MEMORY_MB_USED: lambda a: a["memory_mb_used"],
+            PlacementProperties.DISK_GB_USED: lambda a: a["disk_gb_used"],
+        }
+        try:
+            return mapping[prop]
+        except KeyError as exp:
+            raise QueryPropertyMappingError(
+                f"Error: failed to get property mapping, property {prop.name} is not supported in PlacementProperties"
+            ) from exp
+
+    @staticmethod
+    def get_marker_prop_func():
+        """
+        A getter method to return marker property function for pagination
+        """
+        return PlacementProperties.get_prop_mapping(
+            PlacementProperties.RESOURCE_PROVIDER_ID
+        )

openstackquery/handlers/server_side_handler.py

@@ -87,6 +87,8 @@ def get_filters(
         try:
             filters = filter_func(**params)
         except (KeyError, TypeError) as err:
+            # Dev note: your lambda must take "value" as the lambda
+            # argument if you arrive here adding new mappings
             raise QueryPresetMappingError(
                 "Preset Argument Error: failed to build server-side openstacksdk filters for preset:prop: "
                 f"'{preset.name}':'{prop.name}' "

openstackquery/mappings/hypervisor_mapping.py

@@ -5,14 +5,10 @@
 from openstackquery.enums.query_presets import (
     QueryPresetsGeneric,
     QueryPresetsString,
-    QueryPresetsInteger,
 )
 from openstackquery.handlers.client_side_handler_generic import (
     ClientSideHandlerGeneric,
 )
-from openstackquery.handlers.client_side_handler_integer import (
-    ClientSideHandlerInteger,
-)
 from openstackquery.handlers.client_side_handler_string import ClientSideHandlerString
 from openstackquery.handlers.server_side_handler import ServerSideHandler
 from openstackquery.mappings.mapping_interface import MappingInterface
@@ -72,19 +68,6 @@ def get_client_side_handlers() -> QueryClientSideHandlers:
         corresponding to valid preset-property pairs. These filter functions can be used to filter results after
         listing all hypervisors.
         """
-        integer_props = [
-            HypervisorProperties.HYPERVISOR_DISK_USED,
-            HypervisorProperties.HYPERVISOR_DISK_FREE,
-            HypervisorProperties.HYPERVISOR_DISK_SIZE,
-            HypervisorProperties.HYPERVISOR_MEMORY_SIZE,
-            HypervisorProperties.HYPERVISOR_MEMORY_USED,
-            HypervisorProperties.HYPERVISOR_MEMORY_FREE,
-            HypervisorProperties.HYPERVISOR_VCPUS,
-            HypervisorProperties.HYPERVISOR_VCPUS_USED,
-            # HypervisorProperties.HYPERVISOR_SERVER_COUNT, # Deprecated, use server query
-            # HypervisorProperties.HYPERVISOR_CURRENT_WORKLOAD,
-        ]
-
         return QueryClientSideHandlers(
             # set generic query preset mappings
             generic_handler=ClientSideHandlerGeneric(
@@ -108,12 +91,5 @@ def get_client_side_handlers() -> QueryClientSideHandlers:
             # set datetime query preset mappings
             datetime_handler=None,
             # set integer query preset mappings
-            integer_handler=ClientSideHandlerInteger(
-                {
-                    QueryPresetsInteger.LESS_THAN: integer_props,
-                    QueryPresetsInteger.GREATER_THAN: integer_props,
-                    QueryPresetsInteger.LESS_THAN_OR_EQUAL_TO: integer_props,
-                    QueryPresetsInteger.GREATER_THAN_OR_EQUAL_TO: integer_props,
-                }
-            ),
+            integer_handler=None,
         )

openstackquery/mappings/placement_mapping.py

@@ -0,0 +1,121 @@
+from typing import Type
+
+from openstackquery.enums.props.hypervisor_properties import HypervisorProperties
+from openstackquery.enums.props.placement_properties import PlacementProperties
+from openstackquery.enums.props.prop_enum import PropEnum
+from openstackquery.enums.query_presets import (
+    QueryPresetsGeneric,
+    QueryPresetsString,
+    QueryPresetsInteger,
+)
+from openstackquery.handlers.client_side_handler_generic import (
+    ClientSideHandlerGeneric,
+)
+from openstackquery.handlers.client_side_handler_integer import (
+    ClientSideHandlerInteger,
+)
+from openstackquery.handlers.client_side_handler_string import ClientSideHandlerString
+from openstackquery.handlers.server_side_handler import ServerSideHandler
+from openstackquery.mappings.mapping_interface import MappingInterface
+from openstackquery.runners.placement_runner import PlacementRunner
+
+from openstackquery.runners.runner_wrapper import RunnerWrapper
+from openstackquery.structs.query_client_side_handlers import QueryClientSideHandlers
+
+
+class PlacementMapping(MappingInterface):
+    """
+    Mapping class for querying Openstack placement and resource objects
+    Define property mappings, kwarg mappings and filter function mappings,
+    and runner mapping related to placement and resources here
+    """
+
+    @staticmethod
+    def get_chain_mappings():
+        """
+        Should return a dictionary containing property pairs mapped to query mappings.
+        This is used to define how to chain results from this query to other possible queries
+        """
+        return {
+            PlacementProperties.RESOURCE_PROVIDER_NAME: HypervisorProperties.HYPERVISOR_NAME
+        }
+
+    @staticmethod
+    def get_runner_mapping() -> Type[RunnerWrapper]:
+        """
+        Returns a mapping to associated Runner class for the Query (placement and resourceRunner)
+        """
+        return PlacementRunner
+
+    @staticmethod
+    def get_prop_mapping() -> Type[PropEnum]:
+        """
+        Returns a mapping of valid presets for server side attributes (placement and resourceProperties)
+        """
+        return PlacementProperties
+
+    @staticmethod
+    def get_server_side_handler() -> ServerSideHandler:
+        """
+        method to configure a server handler which can be used to get 'filter' keyword arguments that
+        can be passed to openstack function conn.placement.resource_providers() to filter results
+        Valid filters documented here:
+            https://docs.openstack.org/openstacksdk/latest/user/proxies/placement.html
+        """
+        return ServerSideHandler(
+            {
+                QueryPresetsGeneric.EQUAL_TO: {
+                    PlacementProperties.RESOURCE_PROVIDER_ID: lambda value: {
+                        "id": value
+                    },
+                    PlacementProperties.RESOURCE_PROVIDER_NAME: lambda value: {
+                        "name": value
+                    },
+                }
+            }
+        )
+
+    @staticmethod
+    def get_client_side_handlers() -> QueryClientSideHandlers:
+        """
+        method to configure a set of client-side handlers which can be used to get local filter functions
+        corresponding to valid preset-property pairs. These filter functions can be used to filter results after
+        listing all placement and resources.
+        """
+        integer_prop_list = [
+            PlacementProperties.VCPUS_AVAIL,
+            PlacementProperties.MEMORY_MB_AVAIL,
+            PlacementProperties.DISK_GB_AVAIL,
+            PlacementProperties.VCPUS_USED,
+            PlacementProperties.MEMORY_MB_USED,
+            PlacementProperties.DISK_GB_USED,
+        ]
+
+        return QueryClientSideHandlers(
+            generic_handler=ClientSideHandlerGeneric(
+                {
+                    QueryPresetsGeneric.EQUAL_TO: ["*"],
+                    QueryPresetsGeneric.NOT_EQUAL_TO: ["*"],
+                    QueryPresetsGeneric.ANY_IN: ["*"],
+                    QueryPresetsGeneric.NOT_ANY_IN: ["*"],
+                }
+            ),
+            # set string query preset mappings
+            string_handler=ClientSideHandlerString(
+                {
+                    QueryPresetsString.MATCHES_REGEX: [
+                        PlacementProperties.RESOURCE_PROVIDER_ID,
+                        PlacementProperties.RESOURCE_PROVIDER_NAME,
+                    ]
+                }
+            ),
+            datetime_handler=None,
+            integer_handler=ClientSideHandlerInteger(
+                {
+                    QueryPresetsInteger.LESS_THAN: integer_prop_list,
+                    QueryPresetsInteger.LESS_THAN_OR_EQUAL_TO: integer_prop_list,
+                    QueryPresetsInteger.GREATER_THAN: integer_prop_list,
+                    QueryPresetsInteger.GREATER_THAN_OR_EQUAL_TO: integer_prop_list,
+                }
+            ),
+        )