alihan/openshift-mcp-server
1
0
Fork 0
mirror of https://github.com/openshift/openshift-mcp-server.git synced 2025-10-17 14:27:48 +03:00
Code Issues Packages Projects Releases Wiki Activity

feat(resources): initial support for resource listing

Browse Source
This commit is contained in:
Marc Nuri
2025-02-13 16:06:06 +01:00
parent 590f47c779
commit 80488ef6ee
12 changed files with 384 additions and 109 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
pkg/kubernetes/config.go → pkg/kubernetes/configuration.go
View File

@@ -2,12 +2,10 @@ package kubernetes
import (
"bytes"
"k8s.io/cli-runtime/pkg/genericclioptions"
"k8s.io/cli-runtime/pkg/genericiooptions"
"k8s.io/client-go/tools/clientcmd"
"k8s.io/component-base/cli/flag"
"k8s.io/kubectl/pkg/cmd/config"
"k8s.io/kubectl/pkg/scheme"
)
func ConfigurationView() (string, error) {
@@ -17,7 +15,7 @@ func ConfigurationView() (string, error) {
o := &config.ViewOptions{
IOStreams: ioStreams,
ConfigAccess: pathOptions,
PrintFlags: genericclioptions.NewPrintFlags("").WithTypeSetter(scheme.Scheme).WithDefaultOutput("yaml"),
PrintFlags: defaultPrintFlags(),
Flatten: true,
Minify: true,
Merge: flag.True,

37
pkg/kubernetes/kubernetes.go Normal file
View File

@@ -0,0 +1,37 @@
package kubernetes
import (
"k8s.io/cli-runtime/pkg/genericclioptions"
"k8s.io/client-go/rest"
"k8s.io/client-go/restmapper"
"k8s.io/client-go/tools/clientcmd"
"k8s.io/kubectl/pkg/scheme"
)
type Kubernetes struct {
cfg *rest.Config
deferredDiscoveryRESTMapper *restmapper.DeferredDiscoveryRESTMapper
}
func NewKubernetes() (*Kubernetes, error) {
cfg, err := resolveClientConfig()
if err != nil {
return nil, err
}
return &Kubernetes{cfg: cfg}, nil
}
func defaultPrintFlags() *genericclioptions.PrintFlags {
return genericclioptions.NewPrintFlags("").
WithTypeSetter(scheme.Scheme).
WithDefaultOutput("yaml")
}
func resolveClientConfig() (*rest.Config, error) {
inClusterConfig, err := rest.InClusterConfig()
if err == nil && inClusterConfig != nil {
return inClusterConfig, nil
}
pathOptions := clientcmd.NewDefaultPathOptions()
return clientcmd.BuildConfigFromFlags("", pathOptions.GetDefaultFilename())
}

18
pkg/kubernetes/pods.go Normal file
View File

@@ -0,0 +1,18 @@
package kubernetes
import (
"context"
"k8s.io/apimachinery/pkg/runtime/schema"
)
func (k *Kubernetes) PodsListInAllNamespaces(ctx context.Context) (string, error) {
return k.ResourcesList(ctx, &schema.GroupVersionKind{
Group: "", Version: "v1", Kind: "Pod",
}, "")
}
func (k *Kubernetes) PodsListInNamespace(ctx context.Context, namespace string) (string, error) {
return k.ResourcesList(ctx, &schema.GroupVersionKind{
Group: "", Version: "v1", Kind: "Pod",
}, namespace)
}

52
pkg/kubernetes/resources.go Normal file
View File

@@ -0,0 +1,52 @@
package kubernetes
import (
"context"
"encoding/json"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime/schema"
"k8s.io/client-go/discovery"
memory "k8s.io/client-go/discovery/cached"
"k8s.io/client-go/dynamic"
"k8s.io/client-go/restmapper"
)
// TODO: WIP
func (k *Kubernetes) ResourcesList(ctx context.Context, gvk *schema.GroupVersionKind, namespace string) (string, error) {
client, err := dynamic.NewForConfig(k.cfg)
if err != nil {
return "", err
}
gvr, err := k.resourceFor(gvk)
if err != nil {
return "", err
}
rl, err := client.Resource(*gvr).Namespace("").List(ctx, metav1.ListOptions{})
if err != nil {
return "", err
}
return marshal(rl.Items)
}
func marshal(v any) (string, error) {
ret, err := json.Marshal(v)
if err != nil {
return "", err
}
return string(ret), nil
}
func (k *Kubernetes) resourceFor(gvk *schema.GroupVersionKind) (*schema.GroupVersionResource, error) {
if k.deferredDiscoveryRESTMapper == nil {
d, err := discovery.NewDiscoveryClientForConfig(k.cfg)
if err != nil {
return nil, err
}
k.deferredDiscoveryRESTMapper = restmapper.NewDeferredDiscoveryRESTMapper(memory.NewMemCacheClient(d))
}
m, err := k.deferredDiscoveryRESTMapper.RESTMapping(schema.GroupKind{Group: gvk.Group, Kind: gvk.Kind}, gvk.Version)
if err != nil {
return nil, err
}
return &m.Resource, nil
}

151
pkg/mcp/common_test.go
View File

@@ -6,6 +6,7 @@ import (
"github.com/mark3labs/mcp-go/mcp"
"github.com/mark3labs/mcp-go/server"
"github.com/spf13/afero"
"k8s.io/client-go/kubernetes"
"k8s.io/client-go/rest"
"k8s.io/client-go/tools/clientcmd"
"k8s.io/client-go/tools/clientcmd/api"
@@ -13,17 +14,91 @@ import (
"os"
"path/filepath"
"runtime"
"testing"
"sigs.k8s.io/controller-runtime/pkg/envtest"
"sigs.k8s.io/controller-runtime/tools/setup-envtest/env"
"sigs.k8s.io/controller-runtime/tools/setup-envtest/remote"
"sigs.k8s.io/controller-runtime/tools/setup-envtest/store"
"sigs.k8s.io/controller-runtime/tools/setup-envtest/versions"
"sigs.k8s.io/controller-runtime/tools/setup-envtest/workflows"
"testing"
)
func setupEnvTest() *envtest.Environment {
type mcpContext struct {
ctx context.Context
tempDir string
testServer *httptest.Server
cancel context.CancelFunc
mcpClient *client.SSEMCPClient
envTest *envtest.Environment
}
func (c *mcpContext) beforeEach(t *testing.T) {
var err error
c.ctx, c.cancel = context.WithCancel(context.Background())
c.tempDir = t.TempDir()
c.withKubeConfig(nil)
c.testServer = server.NewTestServer(NewSever().server)
if c.mcpClient, err = client.NewSSEMCPClient(c.testServer.URL + "/sse"); err != nil {
t.Fatal(err)
return
}
if err = c.mcpClient.Start(c.ctx); err != nil {
t.Fatal(err)
return
}
initRequest := mcp.InitializeRequest{}
initRequest.Params.ProtocolVersion = mcp.LATEST_PROTOCOL_VERSION
initRequest.Params.ClientInfo = mcp.Implementation{Name: "test", Version: "1.33.7"}
_, err = c.mcpClient.Initialize(c.ctx, initRequest)
if err != nil {
t.Fatal(err)
return
}
}
func (c *mcpContext) afterEach() {
if c.envTest != nil {
_ = c.envTest.Stop()
}
c.cancel()
_ = c.mcpClient.Close()
c.testServer.Close()
}
func testCase(test func(t *testing.T, c *mcpContext)) func(*testing.T) {
return func(t *testing.T) {
mcpCtx := &mcpContext{}
mcpCtx.beforeEach(t)
defer mcpCtx.afterEach()
test(t, mcpCtx)
}
}
func (c *mcpContext) withKubeConfig(rc *rest.Config) *api.Config {
fakeConfig := api.NewConfig()
fakeConfig.CurrentContext = "fake-context"
fakeConfig.Contexts["fake-context"] = api.NewContext()
fakeConfig.Contexts["fake-context"].Cluster = "fake"
fakeConfig.Contexts["fake-context"].AuthInfo = "fake"
fakeConfig.Clusters["fake"] = api.NewCluster()
fakeConfig.Clusters["fake"].Server = "https://example.com"
fakeConfig.AuthInfos["fake"] = api.NewAuthInfo()
if rc != nil {
fakeConfig.Clusters["fake"].Server = rc.Host
fakeConfig.Clusters["fake"].CertificateAuthorityData = rc.TLSClientConfig.CAData
fakeConfig.AuthInfos["fake"].ClientKeyData = rc.TLSClientConfig.KeyData
fakeConfig.AuthInfos["fake"].ClientCertificateData = rc.TLSClientConfig.CertData
}
kubeConfig := filepath.Join(c.tempDir, "config")
_ = clientcmd.WriteToFile(*fakeConfig, kubeConfig)
_ = os.Setenv("KUBECONFIG", kubeConfig)
return fakeConfig
}
func (c *mcpContext) withEnvTest() {
if c.envTest != nil {
return
}
envTestDir, err := store.DefaultStoreDir()
if err != nil {
panic(err)
@@ -46,70 +121,20 @@ func setupEnvTest() *envtest.Environment {
envTest.CheckCoherence()
workflows.Use{}.Do(envTest)
versionDir := envTest.Platform.Platform.BaseName(*envTest.Version.AsConcrete())
return &envtest.Environment{
c.envTest = &envtest.Environment{
BinaryAssetsDirectory: filepath.Join(envTestDir, "k8s", versionDir),
}
restConfig, _ := c.envTest.Start()
c.withKubeConfig(restConfig)
}
func withKubeConfig(t *testing.T, c *rest.Config) *api.Config {
fakeConfig := api.NewConfig()
fakeConfig.CurrentContext = "fake-context"
fakeConfig.Clusters["fake"] = api.NewCluster()
fakeConfig.Clusters["fake"].Server = c.Host
fakeConfig.Clusters["fake"].CertificateAuthorityData = c.TLSClientConfig.CAData
fakeConfig.Contexts["fake-context"] = api.NewContext()
fakeConfig.Contexts["fake-context"].Cluster = "fake"
fakeConfig.Contexts["fake-context"].AuthInfo = "fake"
fakeConfig.AuthInfos["fake"] = api.NewAuthInfo()
fakeConfig.AuthInfos["fake"].ClientKeyData = c.TLSClientConfig.KeyData
fakeConfig.AuthInfos["fake"].ClientCertificateData = c.TLSClientConfig.CertData
dir := t.TempDir()
kubeConfig := filepath.Join(dir, "config")
clientcmd.WriteToFile(*fakeConfig, kubeConfig)
os.Setenv("KUBECONFIG", kubeConfig)
return fakeConfig
}
type mcpContext struct {
ctx context.Context
testServer *httptest.Server
cancel context.CancelFunc
mcpClient *client.SSEMCPClient
}
func (c *mcpContext) beforeEach(t *testing.T) {
var err error
c.testServer = server.NewTestServer(NewSever().server)
c.ctx, c.cancel = context.WithCancel(context.Background())
if c.mcpClient, err = client.NewSSEMCPClient(c.testServer.URL + "/sse"); err != nil {
t.Fatal(err)
return
}
if err = c.mcpClient.Start(c.ctx); err != nil {
t.Fatal(err)
return
}
initRequest := mcp.InitializeRequest{}
initRequest.Params.ProtocolVersion = mcp.LATEST_PROTOCOL_VERSION
initRequest.Params.ClientInfo = mcp.Implementation{Name: "test", Version: "1.33.7"}
_, err = c.mcpClient.Initialize(c.ctx, initRequest)
func (c *mcpContext) newKubernetesClient() *kubernetes.Clientset {
c.withEnvTest()
pathOptions := clientcmd.NewDefaultPathOptions()
cfg, _ := clientcmd.BuildConfigFromFlags("", pathOptions.GetDefaultFilename())
kubernetesClient, err := kubernetes.NewForConfig(cfg)
if err != nil {
t.Fatal(err)
return
}
}
func (c *mcpContext) afterEach() {
c.cancel()
_ = c.mcpClient.Close()
c.testServer.Close()
}
func testCase(test func(t *testing.T, c *mcpContext)) func(*testing.T) {
return func(t *testing.T) {
mcpCtx := &mcpContext{}
mcpCtx.beforeEach(t)
defer mcpCtx.afterEach()
test(t, mcpCtx)
panic(err)
}
return kubernetesClient
}

27
pkg/mcp/configuration.go
View File

@@ -2,21 +2,22 @@ package mcp
import (
"context"
"fmt"
"github.com/manusa/kubernetes-mcp-server/pkg/kubernetes"
"github.com/mark3labs/mcp-go/mcp"
)
func configurationView(_ context.Context, _ mcp.CallToolRequest) (*mcp.CallToolResult, error) {
cfg, err := kubernetes.ConfigurationView()
if err != nil {
return nil, err
}
return &mcp.CallToolResult{
Content: []interface{}{
mcp.TextContent{
Type: "text",
Text: cfg,
},
},
}, nil
func (s *Sever) initConfiguration() {
s.server.AddTool(mcp.NewTool(
"configuration_view",
mcp.WithDescription("Get the current Kubernetes configuration content as a kubeconfig YAML"),
), configurationView)
}
func configurationView(_ context.Context, _ mcp.CallToolRequest) (*mcp.CallToolResult, error) {
ret, err := kubernetes.ConfigurationView()
if err != nil {
err = fmt.Errorf("failed to get configuration view: %v", err)
}
return NewTextResult(ret, err), nil
}

13
pkg/mcp/configuration_test.go
View File

@@ -7,19 +7,6 @@ import (
)
func TestConfigurationView(t *testing.T) {
envTest := setupEnvTest()
defer envTest.Stop()
envTestConfig, err := envTest.Start()
withKubeConfig(t, envTestConfig)
if err != nil {
t.Errorf("Error starting test environment: %s", err)
return
}
defer func() {
if stopErr := envTest.Stop(); stopErr != nil {
panic(stopErr)
}
}()
t.Run("configuration_view returns configuration", testCase(func(t *testing.T, c *mcpContext) {
configurationGet := mcp.CallToolRequest{}
configurationGet.Params.Name = "configuration_view"

46
pkg/mcp/mcp.go
View File

@@ -11,20 +11,42 @@ type Sever struct {
}
func NewSever() *Sever {
s := server.NewMCPServer(
version.BinaryName,
version.Version,
server.WithResourceCapabilities(true, true),
server.WithPromptCapabilities(true),
server.WithLogging(),
)
s.AddTool(mcp.NewTool(
"configuration_view",
mcp.WithDescription("Get the current Kubernetes configuration content as a kubeconfig YAML"),
), configurationView)
return &Sever{s}
s := &Sever{
server: server.NewMCPServer(
version.BinaryName,
version.Version,
server.WithResourceCapabilities(true, true),
server.WithPromptCapabilities(true),
server.WithLogging(),
),
}
s.initConfiguration()
s.initPods()
return s
}
func (s *Sever) ServeStdio() error {
return server.ServeStdio(s.server)
}
func NewTextResult(content string, err error) *mcp.CallToolResult {
if err != nil {
return &mcp.CallToolResult{
IsError: true,
Content: []interface{}{
mcp.TextContent{
Type: "text",
Text: err.Error(),
},
},
}
}
return &mcp.CallToolResult{
Content: []interface{}{
mcp.TextContent{
Type: "text",
Text: content,
},
},
}
}

13
pkg/mcp/mcp_test.go
View File

@@ -6,11 +6,18 @@ import (
)
func TestTools(t *testing.T) {
expectedNames := []string{"pods_list", "pods_list_in_namespace", "configuration_view"}
t.Run("Has configuration_view tool", testCase(func(t *testing.T, c *mcpContext) {
tools, err := c.mcpClient.ListTools(c.ctx, mcp.ListToolsRequest{})
if tools.Tools[0].Name != "configuration_view" {
t.Fatalf("tool name mismatch %v", err)
return
nameSet := make(map[string]bool)
for _, tool := range tools.Tools {
nameSet[tool.Name] = true
}
for _, name := range expectedNames {
if nameSet[name] != true {
t.Fatalf("tool name mismatch %v", err)
return
}
}
}))
}

52
pkg/mcp/pods.go Normal file
View File

@@ -0,0 +1,52 @@
package mcp
import (
"context"
"errors"
"fmt"
"github.com/manusa/kubernetes-mcp-server/pkg/kubernetes"
"github.com/mark3labs/mcp-go/mcp"
)
func (s *Sever) initPods() {
s.server.AddTool(mcp.NewTool(
"pods_list",
mcp.WithDescription("List all the Kubernetes pods in the current cluster from all namespaces"),
), podsListInAllNamespaces)
s.server.AddTool(mcp.NewTool(
"pods_list_in_namespace",
mcp.WithDescription("List all the Kubernetes pods in the specified namespace in the current cluster"),
mcp.WithString("namespace",
mcp.Description("Namespace to list pods from"),
mcp.Required(),
),
), podsListInNamespace)
}
func podsListInAllNamespaces(ctx context.Context, _ mcp.CallToolRequest) (*mcp.CallToolResult, error) {
k, err := kubernetes.NewKubernetes()
if err != nil {
return NewTextResult("", fmt.Errorf("failed to list pods in all namespaces: %v", err)), nil
}
ret, err := k.PodsListInAllNamespaces(ctx)
if err != nil {
return NewTextResult("", fmt.Errorf("failed to list pods in all namespaces: %v", err)), nil
}
return NewTextResult(ret, err), nil
}
func podsListInNamespace(ctx context.Context, ctr mcp.CallToolRequest) (*mcp.CallToolResult, error) {
k, err := kubernetes.NewKubernetes()
if err != nil {
return NewTextResult("", fmt.Errorf("failed to list pods in namespace: %v", err)), nil
}
ns := ctr.Params.Arguments["namespace"]
if ns == nil {
return NewTextResult("", errors.New("failed to list pods in namespace, missing argument namespace")), nil
}
ret, err := k.PodsListInNamespace(ctx, ns.(string))
if err != nil {
return NewTextResult("", fmt.Errorf("failed to list pods in namespace %s: %v", ns, err)), nil
}
return NewTextResult(ret, err), nil
}

76
pkg/mcp/pods_test.go Normal file
View File

@@ -0,0 +1,76 @@
package mcp
import (
"context"
"encoding/json"
"github.com/mark3labs/mcp-go/mcp"
corev1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/client-go/kubernetes"
"testing"
)
func TestPodsListInAllNamespaces(t *testing.T) {
t.Run("pods_list", testCase(func(t *testing.T, c *mcpContext) {
createTestData(c.ctx, c.newKubernetesClient())
configurationGet := mcp.CallToolRequest{}
configurationGet.Params.Name = "pods_list"
configurationGet.Params.Arguments = map[string]interface{}{}
toolResult, err := c.mcpClient.CallTool(c.ctx, configurationGet)
if err != nil {
t.Fatalf("call tool failed %v", err)
return
}
var decoded []unstructured.Unstructured
if json.Unmarshal([]byte(toolResult.Content[0].(map[string]interface{})["text"].(string)), &decoded) != nil {
t.Fatalf("invalid tool result content %v", err)
return
}
if len(decoded) != 2 {
t.Fatalf("invalid pods count, expected 2, got %v", len(decoded))
return
}
if decoded[0].GetName() != "a-pod-in-ns-1" {
t.Fatalf("invalid pod name, expected a-pod-in-ns-1, got %v", decoded[0].GetName())
return
}
if decoded[0].GetNamespace() != "ns-1" {
t.Fatalf("invalid pod namespace, expected ns-1, got %v", decoded[0].GetNamespace())
return
}
if decoded[1].GetName() != "a-pod-in-ns-2" {
t.Fatalf("invalid pod name, expected a-pod-in-ns-2, got %v", decoded[1].GetName())
return
}
if decoded[1].GetNamespace() != "ns-2" {
t.Fatalf("invalid pod namespace, expected ns-2, got %v", decoded[1].GetNamespace())
return
}
}))
}
func createTestData(ctx context.Context, kc *kubernetes.Clientset) {
_, _ = kc.CoreV1().Namespaces().
Create(ctx, &corev1.Namespace{ObjectMeta: metav1.ObjectMeta{Name: "ns-1"}}, metav1.CreateOptions{})
_, _ = kc.CoreV1().Namespaces().
Create(ctx, &corev1.Namespace{ObjectMeta: metav1.ObjectMeta{Name: "ns-2"}}, metav1.CreateOptions{})
_, _ = kc.CoreV1().Pods("ns-1").
Create(ctx, &corev1.Pod{
ObjectMeta: metav1.ObjectMeta{Name: "a-pod-in-ns-1"},
Spec: corev1.PodSpec{
Containers: []corev1.Container{
{Name: "nginx", Image: "nginx"},
},
},
}, metav1.CreateOptions{})
_, _ = kc.CoreV1().Pods("ns-2").
Create(ctx, &corev1.Pod{
ObjectMeta: metav1.ObjectMeta{Name: "a-pod-in-ns-2"},
Spec: corev1.PodSpec{
Containers: []corev1.Container{
{Name: "nginx", Image: "nginx"},
},
},
}, metav1.CreateOptions{})
}