feat: get flavors

Author: choieastsea

src/openstack_mcp_server/tools/compute_tools.py

@@ -2,7 +2,10 @@
 
 from fastmcp import FastMCP
 
-from openstack_mcp_server.tools.response.compute import Server
+from openstack_mcp_server.tools.response.compute import (
+    Flavor,
+    Server,
+)
 
 from .base import get_openstack_conn
 
@@ -16,10 +19,10 @@ def register_tools(self, mcp: FastMCP):
         """
         Register Compute-related tools with the FastMCP instance.
         """
-
         mcp.tool()(self.get_servers)
         mcp.tool()(self.get_server)
         mcp.tool()(self.create_server)
+        mcp.tool()(self.get_flavors)
 
     def get_servers(self) -> list[Server]:
         """
@@ -60,7 +63,7 @@ def create_server(
 
         :param name: The name of the server.
         :param image: The ID of the image to use.
-        :param flavor: The (integer) ID of the flavor to use.
+        :param flavor: The ID of the flavor to use.
         :param network: The ID of the network to attach.
         :param key_name: The name of the key pair to use.
         :param security_groups: A list of security group names to attach.
@@ -87,3 +90,15 @@ def create_server(
         server = conn.compute.get_server(resp.id)
 
         return Server(**server)
+
+    def get_flavors(self) -> list[Flavor]:
+        """
+        Get flavors (server hardware configurations).
+
+        :return: A list of Flavor objects.
+        """
+        conn = get_openstack_conn()
+        flavor_list = []
+        for flavor in conn.compute.flavors():
+            flavor_list.append(Flavor(**flavor))
+        return flavor_list

src/openstack_mcp_server/tools/response/compute.py

@@ -1,13 +1,13 @@
 from pydantic import BaseModel, ConfigDict, Field
 
 
-class Flavor(BaseModel):
+class ServerFlavor(BaseModel):
     id: str | None = Field(default=None, exclude=True)
     name: str = Field(validation_alias="original_name")
     model_config = ConfigDict(validate_by_name=True)
 
 
-class Image(BaseModel):
+class ServerImage(BaseModel):
     id: str
 
 
@@ -27,8 +27,20 @@ class Server(BaseModel):
     id: str
     name: str
     status: str | None = None
-    flavor: Flavor | None = None
-    image: Image | None = None
+    flavor: ServerFlavor | None = None
+    image: ServerImage | None = None
     addresses: dict[str, list[ServerIp]] | None = None
     key_name: str | None = None
     security_groups: list[ServerSecurityGroup] | None = None
+
+
+class Flavor(BaseModel):
+    id: str
+    name: str
+    vcpus: int
+    ram: int
+    disk: int
+    swap: int | None = None
+    is_public: bool = Field(validation_alias="os-flavor-access:is_public")
+
+    model_config = ConfigDict(validate_by_name=True)

tests/tools/test_compute_tools.py

@@ -3,8 +3,9 @@
 from openstack_mcp_server.tools.compute_tools import ComputeTools
 from openstack_mcp_server.tools.response.compute import (
     Flavor,
-    Image,
     Server,
+    ServerFlavor,
+    ServerImage,
     ServerIp,
     ServerSecurityGroup,
 )
@@ -79,8 +80,8 @@ def test_get_servers_success(self, mock_get_openstack_conn):
                 id="434eb822-3fbd-44a1-a000-3b511ac9b516",
                 name="web-server-01",
                 status="ACTIVE",
-                flavor=Flavor(id=None, name="m1.tiny"),
-                image=Image(id="de527f30-d078-41f4-8f18-a23bf2d39366"),
+                flavor=ServerFlavor(id=None, name="m1.tiny"),
+                image=ServerImage(id="de527f30-d078-41f4-8f18-a23bf2d39366"),
                 addresses={
                     "private": [
                         ServerIp(addr="192.168.1.10", version=4, type="fixed"),
@@ -93,8 +94,8 @@ def test_get_servers_success(self, mock_get_openstack_conn):
                 id="ffd071fe-1334-45f6-8894-5b0bcac262a6",
                 name="db-server-01",
                 status="SHUTOFF",
-                flavor=Flavor(id=None, name="m1.small"),
-                image=Image(id="3d897e0e-4117-46bb-ae77-e734bb16a1ca"),
+                flavor=ServerFlavor(id=None, name="m1.small"),
+                image=ServerImage(id="3d897e0e-4117-46bb-ae77-e734bb16a1ca"),
                 addresses={
                     "net1": [
                         ServerIp(addr="192.168.1.11", version=4, type="fixed"),
@@ -258,9 +259,10 @@ def test_register_tools(self):
                 call(compute_tools.get_servers),
                 call(compute_tools.get_server),
                 call(compute_tools.create_server),
+                call(compute_tools.get_flavors),
             ],
         )
-        assert mock_tool_decorator.call_count == 3
+        assert mock_tool_decorator.call_count == 4
 
     def test_compute_tools_instantiation(self):
         """Test ComputeTools can be instantiated."""
@@ -279,3 +281,67 @@ def test_get_servers_docstring(self):
         assert docstring is not None
         assert "Get the list of Compute servers" in docstring
         assert "return" in docstring.lower() or "Return" in docstring
+
+    def test_get_flavors_success(self, mock_get_openstack_conn):
+        """Test getting flavors successfully."""
+        mock_conn = mock_get_openstack_conn
+
+        # Create mock flavor objects
+        mock_flavor1 = {
+            "id": "1",
+            "name": "m1.tiny",
+            "vcpus": 1,
+            "ram": 512,
+            "disk": 1,
+            "swap": 0,
+            "os-flavor-access:is_public": True,
+        }
+
+        mock_flavor2 = {
+            "id": "2",
+            "name": "m1.small",
+            "vcpus": 2,
+            "ram": 2048,
+            "disk": 20,
+            "swap": 0,
+            "os-flavor-access:is_public": True,
+        }
+
+        mock_conn.compute.flavors.return_value = [mock_flavor1, mock_flavor2]
+
+        compute_tools = ComputeTools()
+        result = compute_tools.get_flavors()
+
+        expected_output = [
+            Flavor(
+                id="1",
+                name="m1.tiny",
+                vcpus=1,
+                ram=512,
+                disk=1,
+                swap=0,
+                is_public=True,
+            ),
+            Flavor(
+                id="2",
+                name="m1.small",
+                vcpus=2,
+                ram=2048,
+                disk=20,
+                swap=0,
+                is_public=True,
+            ),
+        ]
+        assert result == expected_output
+        mock_conn.compute.flavors.assert_called_once()
+
+    def test_get_flavors_empty_list(self, mock_get_openstack_conn):
+        """Test getting flavors when no flavors exist."""
+        mock_conn = mock_get_openstack_conn
+        mock_conn.compute.flavors.return_value = []
+
+        compute_tools = ComputeTools()
+        result = compute_tools.get_flavors()
+
+        assert result == []
+        mock_conn.compute.flavors.assert_called_once()