feat: add open source codeHEADmaster

Add the initial open source version of K9P with support for viewing
namespaces and deployments. Current support is entirely read-only.
Performance is pretty terrible. Needs much more love and care.

7 files changed, 523 insertions, 0 deletions

diff --git a/pkg/resources/deployments.go b/pkg/resources/deployments.go
new file mode 100644
index 0000000..065d03b
--- /dev/null
+++ b/pkg/resources/deployments.go
@@ -0,0 +1,184 @@
+package resources
+
+import (
+	"context"
+	"io"
+	"math/rand"
+	"strconv"
+	"time"
+
+	"github.com/docker/go-p9p"
+	v1 "k8s.io/api/apps/v1"
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/labels"
+	appsv1 "k8s.io/client-go/informers/apps/v1"
+	"sigs.k8s.io/yaml"
+)
+
+type Deployments struct {
+	namespace          string
+	deploymentInformer appsv1.DeploymentInformer
+	session            Session
+	info               *p9p.Dir
+	readdir            *p9p.Readdir
+}
+
+func NewDeployments(namespace string, session Session) *Deployments {
+	deploymentInformer := session.Informer().Apps().V1().Deployments()
+	return &Deployments{
+		namespace:          namespace,
+		deploymentInformer: deploymentInformer,
+		session:            session,
+	}
+}
+
+func (r *Deployments) Info() p9p.Dir {
+	if r.info != nil {
+		return *r.info
+	}
+
+	dir := p9p.Dir{}
+	dir.Qid.Path = rand.Uint64()
+	dir.Qid.Version = 0
+
+	dir.Name = "deployments"
+	dir.Mode = 0664
+	dir.Length = 0
+	dir.AccessTime = time.Now()
+	dir.ModTime = time.Now()
+	dir.MUID = "none"
+
+	uname, _ := r.session.GetAuth()
+	dir.UID = uname
+	dir.GID = uname
+
+	dir.Qid.Type |= p9p.QTDIR
+	dir.Mode |= p9p.DMDIR
+	r.info = &dir
+
+	return dir
+}
+
+func (r *Deployments) Get(name string) (Ref, error) {
+	deployment, err := r.deploymentInformer.Lister().Deployments(r.namespace).Get(name)
+	if apierrors.IsNotFound(err) {
+		return nil, p9p.ErrNotfound
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	return NewDeploymentRef(deployment, r.session), nil
+}
+
+func (r *Deployments) Read(ctx context.Context, p []byte, offset int64) (n int, err error) {
+	if r.readdir != nil {
+		return r.readdir.Read(ctx, p, offset)
+	}
+
+	deployments, err := r.deploymentInformer.Lister().Deployments(r.namespace).List(labels.Everything())
+	if err != nil {
+		return 0, err
+	}
+
+	deploymentRefs := make([]Ref, 0, len(deployments))
+
+	for _, deployment := range deployments {
+		deployment := deployment
+		deploymentRefs = append(deploymentRefs, NewDeploymentRef(deployment, r.session))
+	}
+
+	r.readdir = p9p.NewReaddir(p9p.NewCodec(), func() (p9p.Dir, error) {
+		if len(deploymentRefs) == 0 {
+			return p9p.Dir{}, io.EOF
+		}
+
+		deployment := deploymentRefs[0]
+		deploymentRefs = deploymentRefs[1:]
+
+		return deployment.Info(), nil
+	})
+
+	n, err = r.readdir.Read(ctx, p, offset)
+
+	return n, err
+}
+
+type DeploymentRef struct {
+	deployment *v1.Deployment
+	session    Session
+	info       *p9p.Dir
+	readdir    *p9p.Readdir
+	children   map[string]Ref
+}
+
+func NewDeploymentRef(deployment *v1.Deployment, session Session) *DeploymentRef {
+	y, _ := yaml.Marshal(deployment)
+	children := map[string]Ref{
+		"data.yaml": &Static{
+			name:    "data.yaml",
+			content: y,
+			session: session,
+		},
+		"scale": &Static{
+			name:    "scale",
+			content: []byte(strconv.Itoa(int(*deployment.Spec.Replicas))),
+			session: session,
+		},
+	}
+	return &DeploymentRef{
+		deployment: deployment,
+		session:    session,
+		children:   children,
+	}
+}
+
+func (r *DeploymentRef) Info() p9p.Dir {
+	if r.info != nil {
+		return *r.info
+	}
+
+	dir := p9p.Dir{}
+	dir.Qid.Path = rand.Uint64()
+	dir.Qid.Version = 0
+
+	dir.Name = r.deployment.Name
+	dir.Mode = 0664
+	dir.Length = 0
+	dir.AccessTime = r.deployment.CreationTimestamp.Time
+	dir.ModTime = r.deployment.CreationTimestamp.Time
+	dir.MUID = "none"
+
+	uname, _ := r.session.GetAuth()
+	dir.UID = uname
+	dir.GID = uname
+
+	dir.Qid.Type |= p9p.QTDIR
+	dir.Mode |= p9p.DMDIR
+	r.info = &dir
+
+	return dir
+}
+
+func (r *DeploymentRef) Get(name string) (Ref, error) {
+	ref, ok := r.children[name]
+	if !ok {
+		return nil, p9p.ErrNotfound
+	}
+
+	return ref, nil
+}
+
+func (r *DeploymentRef) Read(ctx context.Context, p []byte, offset int64) (int, error) {
+	if r.readdir != nil {
+		return r.readdir.Read(ctx, p, offset)
+	}
+
+	dir := make([]p9p.Dir, 0, len(r.children))
+	for _, child := range r.children {
+		dir = append(dir, child.Info())
+	}
+
+	r.readdir = p9p.NewFixedReaddir(p9p.NewCodec(), dir)
+	return r.readdir.Read(ctx, p, offset)
+}
diff --git a/pkg/resources/files.go b/pkg/resources/files.go
new file mode 100644
index 0000000..64cf892
--- /dev/null
+++ b/pkg/resources/files.go
@@ -0,0 +1,60 @@
+package resources
+
+import (
+	"context"
+	"math/rand"
+	"time"
+
+	"github.com/docker/go-p9p"
+	"github.com/rs/zerolog/log"
+)
+
+type Static struct {
+	name    string
+	offset  int64
+	content []byte
+	info    *p9p.Dir
+	session Session
+}
+
+func (r *Static) Info() p9p.Dir {
+	if r.info != nil {
+		return *r.info
+	}
+
+	dir := p9p.Dir{}
+	dir.Qid.Path = rand.Uint64()
+	dir.Qid.Version = 0
+
+	dir.Name = r.name
+	dir.Mode = 0664
+	dir.Length = 0
+	dir.AccessTime = time.Now()
+	dir.ModTime = time.Now()
+	dir.MUID = "none"
+
+	uname, _ := r.session.GetAuth()
+	dir.UID = uname
+	dir.GID = uname
+
+	dir.Qid.Type |= p9p.QTFILE
+
+	r.info = &dir
+	return dir
+}
+
+func (r *Static) Get(name string) (Ref, error) {
+	return nil, p9p.ErrWalknodir
+}
+
+func (r *Static) Read(ctx context.Context, p []byte, offset int64) (n int, err error) {
+	log.Debug().Int64("offset", r.offset).Str("name", r.name).Send()
+	if offset != r.offset {
+		return 0, p9p.ErrBadoffset
+	}
+
+	n = copy(p, r.content[offset:])
+	r.offset += int64(n)
+
+	return n, nil
+}
diff --git a/pkg/resources/namespace.go b/pkg/resources/namespace.go
new file mode 100644
index 0000000..df08c2d
--- /dev/null
+++ b/pkg/resources/namespace.go
@@ -0,0 +1,68 @@
+package resources
+
+import (
+	"context"
+	"math/rand"
+
+	"github.com/docker/go-p9p"
+	v1 "k8s.io/api/core/v1"
+	"k8s.io/client-go/kubernetes"
+)
+
+type NamespaceRef struct {
+	namespace *v1.Namespace
+	client    kubernetes.Interface
+	session   Session
+	info      *p9p.Dir
+	readdir   *p9p.Readdir
+}
+
+func (r *NamespaceRef) Info() p9p.Dir {
+	if r.info != nil {
+		return *r.info
+	}
+
+	dir := p9p.Dir{}
+	dir.Qid.Path = rand.Uint64()
+	dir.Qid.Version = uint32(r.namespace.Generation)
+
+	dir.Name = r.namespace.Name
+	dir.Mode = 0664
+	dir.Length = 0
+	dir.AccessTime = r.namespace.CreationTimestamp.Time
+	dir.ModTime = r.namespace.CreationTimestamp.Time
+	dir.MUID = "none"
+
+	uname, _ := r.session.GetAuth()
+	dir.UID = uname
+	dir.GID = uname
+
+	dir.Qid.Type |= p9p.QTDIR
+	dir.Mode |= p9p.DMDIR
+
+	r.info = &dir
+	return dir
+}
+
+func (r *NamespaceRef) Get(name string) (Ref, error) {
+	switch name {
+	case "deployments":
+		return NewDeployments(r.namespace.Name, r.session), nil
+	}
+
+	return nil, p9p.ErrNotfound
+}
+
+func (r *NamespaceRef) Read(ctx context.Context, p []byte, offset int64) (n int, err error) {
+	if r.readdir != nil {
+		return r.readdir.Read(ctx, p, offset)
+	}
+
+	deployments := NewDeployments(r.namespace.Name, r.session)
+	dir := []p9p.Dir{
+		deployments.Info(),
+	}
+
+	r.readdir = p9p.NewFixedReaddir(p9p.NewCodec(), dir)
+	return r.readdir.Read(ctx, p, offset)
+}
diff --git a/pkg/resources/namespaces.go b/pkg/resources/namespaces.go
new file mode 100644
index 0000000..15ea9d6
--- /dev/null
+++ b/pkg/resources/namespaces.go
@@ -0,0 +1,110 @@
+package resources
+
+import (
+	"context"
+	"io"
+	"math/rand"
+	"time"
+
+	"github.com/docker/go-p9p"
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/labels"
+	corev1 "k8s.io/client-go/informers/core/v1"
+	"k8s.io/client-go/kubernetes"
+)
+
+type NamespacesRef struct {
+	client            kubernetes.Interface
+	namespaceInformer corev1.NamespaceInformer
+	session           Session
+	info              *p9p.Dir
+	readdir           *p9p.Readdir
+}
+
+func NewNamespacesRef(client kubernetes.Interface, session Session) *NamespacesRef {
+	namespaceInformer := session.Informer().Core().V1().Namespaces()
+
+	return &NamespacesRef{
+		client:            client,
+		namespaceInformer: namespaceInformer,
+		session:           session,
+	}
+}
+
+func (r *NamespacesRef) Info() p9p.Dir {
+	if r.info != nil {
+		return *r.info
+	}
+
+	dir := p9p.Dir{}
+	dir.Qid.Path = rand.Uint64()
+	dir.Qid.Version = 0
+
+	dir.Name = "namespaces"
+	dir.Mode = 0664
+	dir.Length = 0
+	dir.AccessTime = time.Now()
+	dir.ModTime = time.Now()
+	dir.MUID = "none"
+
+	uname, _ := r.session.GetAuth()
+	dir.UID = uname
+	dir.GID = uname
+
+	dir.Qid.Type |= p9p.QTDIR
+	dir.Mode |= p9p.DMDIR
+	r.info = &dir
+
+	return dir
+}
+
+func (r *NamespacesRef) Get(name string) (Ref, error) {
+	namespace, err := r.namespaceInformer.Lister().Get(name)
+	if apierrors.IsNotFound(err) {
+		return nil, p9p.ErrNotfound
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	return &NamespaceRef{
+		namespace: namespace,
+		client:    r.client,
+		session:   r.session,
+	}, nil
+}
+
+func (r *NamespacesRef) Read(ctx context.Context, p []byte, offset int64) (n int, err error) {
+	if r.readdir != nil {
+		return r.readdir.Read(ctx, p, offset)
+	}
+
+	namespaces, err := r.namespaceInformer.Lister().List(labels.Everything())
+	if err != nil {
+		return 0, err
+	}
+
+	namespaceRefs := make([]NamespaceRef, 0, len(namespaces))
+
+	for _, namespace := range namespaces {
+		namespace := namespace
+		namespaceRefs = append(namespaceRefs, NamespaceRef{
+			namespace: namespace,
+			client:    r.client,
+			session:   r.session,
+		})
+	}
+
+	r.readdir = p9p.NewReaddir(p9p.NewCodec(), func() (p9p.Dir, error) {
+		if len(namespaceRefs) == 0 {
+			return p9p.Dir{}, io.EOF
+		}
+
+		ns := namespaceRefs[0]
+		namespaceRefs = namespaceRefs[1:]
+
+		return ns.Info(), nil
+	})
+
+	return r.readdir.Read(ctx, p, offset)
+}
diff --git a/pkg/resources/refs.go b/pkg/resources/refs.go
new file mode 100644
index 0000000..3ede9e7
--- /dev/null
+++ b/pkg/resources/refs.go
@@ -0,0 +1,13 @@
+package resources
+
+import (
+	"context"
+
+	"github.com/docker/go-p9p"
+)
+
+type Ref interface {
+	Info() p9p.Dir
+	Get(name string) (Ref, error)
+	Read(ctx context.Context, p []byte, offset int64) (n int, err error)
+}
diff --git a/pkg/resources/resources.go b/pkg/resources/resources.go
new file mode 100644
index 0000000..8c2eed5
--- /dev/null
+++ b/pkg/resources/resources.go
@@ -0,0 +1,12 @@
+package resources
+
+import (
+	"github.com/docker/go-p9p"
+	"k8s.io/client-go/informers"
+)
+
+type Session interface {
+	p9p.Session
+	GetAuth() (uname, aname string)
+	Informer() informers.SharedInformerFactory
+}
diff --git a/pkg/resources/staticdir.go b/pkg/resources/staticdir.go
new file mode 100644
index 0000000..cfa969a
--- /dev/null
+++ b/pkg/resources/staticdir.go
@@ -0,0 +1,76 @@
+package resources
+
+import (
+	"context"
+	"math/rand"
+	"time"
+
+	"github.com/docker/go-p9p"
+)
+
+type DirRef struct {
+	path     string
+	info     p9p.Dir
+	session  Session
+	children map[string]Ref
+	readdir  *p9p.Readdir
+}
+
+func NewDirRef(path string, session Session, children map[string]Ref) *DirRef {
+	d := &DirRef{
+		path:     path,
+		session:  session,
+		children: children,
+	}
+	d.info = d.createInfo()
+
+	return d
+}
+
+func (d *DirRef) createInfo() p9p.Dir {
+	dir := p9p.Dir{}
+	dir.Qid.Path = rand.Uint64()
+	dir.Qid.Version = 0
+
+	dir.Name = d.path
+	dir.Mode = 0664
+	dir.Length = 0
+	dir.AccessTime = time.Now()
+	dir.ModTime = time.Now()
+	dir.MUID = "none"
+
+	uname, _ := d.session.GetAuth()
+	dir.UID = uname
+	dir.GID = uname
+
+	dir.Qid.Type |= p9p.QTDIR
+	dir.Mode |= p9p.DMDIR
+
+	return dir
+}
+
+func (d *DirRef) Info() p9p.Dir {
+	return d.info
+}
+
+func (d *DirRef) Get(name string) (Ref, error) {
+	child, ok := d.children[name]
+	if !ok {
+		return nil, p9p.ErrNotfound
+	}
+
+	return child, nil
+}
+
+func (d *DirRef) Read(ctx context.Context, p []byte, offset int64) (n int, err error) {
+	if d.readdir != nil {
+		return d.readdir.Read(ctx, p, offset)
+	}
+
+	dir := make([]p9p.Dir, 0, len(d.children))
+	for _, child := range d.children {
+		dir = append(dir, child.Info())
+	}
+	d.readdir = p9p.NewFixedReaddir(p9p.NewCodec(), dir)
+	return d.readdir.Read(ctx, p, offset)
+}