Implement Fargate pod and container objects

providers/aws/provider.go

@@ -6,6 +6,7 @@ import (
 	"time"
 
 	"github.com/virtual-kubelet/virtual-kubelet/manager"
+	"github.com/virtual-kubelet/virtual-kubelet/providers/aws/fargate"
 
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/resource"
@@ -26,6 +27,7 @@ type FargateProvider struct {
 	securityGroups []string
 
 	// Fargate resources.
+	cluster                 *fargate.Cluster
 	clusterName             string
 	capacity                capacity
 	assignPublicIPv4Address bool
@@ -74,6 +76,23 @@ func NewFargateProvider(
 
 	log.Printf("Loaded provider configuration file %s.", config)
 
+	// Find or create the configured Fargate cluster.
+	clusterConfig := fargate.ClusterConfig{
+		Region:                  p.region,
+		Name:                    p.clusterName,
+		NodeName:                nodeName,
+		Subnets:                 p.subnets,
+		SecurityGroups:          p.securityGroups,
+		AssignPublicIPv4Address: p.assignPublicIPv4Address,
+		PlatformVersion:         p.platformVersion,
+	}
+
+	p.cluster, err = fargate.NewCluster(&clusterConfig)
+	if err != nil {
+		err = fmt.Errorf("failed to create Fargate cluster: %v", err)
+		return nil, err
+	}
+
 	p.lastTransitionTime = time.Now()
 
 	log.Printf("Created Fargate provider: %+v.", p)
@@ -84,7 +103,20 @@ func NewFargateProvider(
 // CreatePod takes a Kubernetes Pod and deploys it within the Fargate provider.
 func (p *FargateProvider) CreatePod(pod *corev1.Pod) error {
 	log.Printf("Received CreatePod request for %+v.\n", pod)
-	return errNotImplemented
+
+	fgPod, err := fargate.NewPod(p.cluster, pod)
+	if err != nil {
+		log.Printf("Failed to create pod: %v.\n", err)
+		return err
+	}
+
+	err = fgPod.Start()
+	if err != nil {
+		log.Printf("Failed to start pod: %v.\n", err)
+		return err
+	}
+
+	return nil
 }
 
 // UpdatePod takes a Kubernetes Pod and updates it within the provider.
@@ -96,13 +128,41 @@ func (p *FargateProvider) UpdatePod(pod *corev1.Pod) error {
 // DeletePod takes a Kubernetes Pod and deletes it from the provider.
 func (p *FargateProvider) DeletePod(pod *corev1.Pod) error {
 	log.Printf("Received DeletePod request for %s/%s.\n", pod.Namespace, pod.Name)
-	return errNotImplemented
+
+	fgPod, err := p.cluster.GetPod(pod.Namespace, pod.Name)
+	if err != nil {
+		log.Printf("Failed to get pod: %v.\n", err)
+		return err
+	}
+
+	err = fgPod.Stop()
+	if err != nil {
+		log.Printf("Failed to stop pod: %v.\n", err)
+		return err
+	}
+
+	return nil
 }
 
 // GetPod retrieves a pod by name from the provider (can be cached).
 func (p *FargateProvider) GetPod(namespace, name string) (*corev1.Pod, error) {
 	log.Printf("Received GetPod request for %s/%s.\n", namespace, name)
-	return nil, errNotImplemented
+
+	pod, err := p.cluster.GetPod(namespace, name)
+	if err != nil {
+		log.Printf("Failed to get pod: %v.\n", err)
+		return nil, err
+	}
+
+	spec, err := pod.GetSpec()
+	if err != nil {
+		log.Printf("Failed to get pod spec: %v.\n", err)
+		return nil, err
+	}
+
+	log.Printf("Responding to GetPod: %+v.\n", spec)
+
+	return spec, nil
 }
 
 // GetContainerLogs retrieves the logs of a container by name from the provider.
@@ -114,13 +174,45 @@ func (p *FargateProvider) GetContainerLogs(namespace, podName, containerName str
 // GetPodStatus retrieves the status of a pod by name from the provider.
 func (p *FargateProvider) GetPodStatus(namespace, name string) (*corev1.PodStatus, error) {
 	log.Printf("Received GetPodStatus request for %s/%s.\n", namespace, name)
-	return nil, errNotImplemented
+
+	pod, err := p.cluster.GetPod(namespace, name)
+	if err != nil {
+		log.Printf("Failed to get pod: %v.\n", err)
+		return nil, err
+	}
+
+	status := pod.GetStatus()
+
+	log.Printf("Responding to GetPodStatus: %+v.\n", status)
+
+	return &status, nil
 }
 
 // GetPods retrieves a list of all pods running on the provider (can be cached).
 func (p *FargateProvider) GetPods() ([]*corev1.Pod, error) {
 	log.Println("Received GetPods request.")
-	return nil, errNotImplemented
+
+	pods, err := p.cluster.GetPods()
+	if err != nil {
+		log.Printf("Failed to get pods: %v.\n", err)
+		return nil, err
+	}
+
+	var result []*corev1.Pod
+
+	for _, pod := range pods {
+		spec, err := pod.GetSpec()
+		if err != nil {
+			log.Printf("Failed to get pod spec: %v.\n", err)
+			continue
+		}
+
+		result = append(result, spec)
+	}
+
+	log.Printf("Responding to GetPods: %+v.\n", result)
+
+	return result, nil
 }
 
 // Capacity returns a resource list with the capacity constraints of the provider.