vendor: initial vendor

Signed-off-by: Tonis Tiigi <tonistiigi@gmail.com>

vendor/github.com/docker/compose-on-kubernetes/api/compose/v1beta1/doc.go

@@ -0,0 +1,10 @@
+// Api versions allow the api contract for a resource to be changed while keeping
+// backward compatibility by support multiple concurrent versions
+// of the same resource
+
+// Package v1beta1 is the first version of the Stack spec, containing only a compose file
+// +k8s:openapi-gen=true
+// +k8s:deepcopy-gen=package,register
+// +k8s:defaulter-gen=TypeMeta
+// +groupName=compose.docker.com
+package v1beta1

vendor/github.com/docker/compose-on-kubernetes/api/compose/v1beta1/owner.go

@@ -0,0 +1,31 @@
+package v1beta1
+
+import (
+	"github.com/docker/compose-on-kubernetes/api/compose/impersonation"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+)
+
+// Owner defines the owner of a stack. It is used to impersonate the controller calls
+// to kubernetes api.
+type Owner struct {
+	metav1.TypeMeta   `json:",inline"`
+	metav1.ObjectMeta `json:"metadata,omitempty"`
+	Owner             impersonation.Config `json:"owner,omitempty"`
+}
+
+func (o *Owner) clone() *Owner {
+	if o == nil {
+		return nil
+	}
+	result := new(Owner)
+	result.TypeMeta = o.TypeMeta
+	result.ObjectMeta = o.ObjectMeta
+	result.Owner = *result.Owner.Clone()
+	return result
+}
+
+// DeepCopyObject clones the owner
+func (o *Owner) DeepCopyObject() runtime.Object {
+	return o.clone()
+}

vendor/github.com/docker/compose-on-kubernetes/api/compose/v1beta1/parsing.go

@@ -0,0 +1,4 @@
+package v1beta1
+
+// MaxComposeVersion is the most recent version of compose file Schema supported in v1beta1
+const MaxComposeVersion = "3.5"

vendor/github.com/docker/compose-on-kubernetes/api/compose/v1beta1/register.go

@@ -0,0 +1,39 @@
+package v1beta1
+
+import (
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+)
+
+// GroupName is the group name used to register these objects
+const GroupName = "compose.docker.com"
+
+// Alias variables for the registration
+var (
+	// SchemeGroupVersion is group version used to register these objects
+	SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1beta1"}
+	SchemeBuilder      runtime.SchemeBuilder
+	localSchemeBuilder = &SchemeBuilder
+	AddToScheme        = localSchemeBuilder.AddToScheme
+)
+
+func init() {
+	localSchemeBuilder.Register(addKnownTypes)
+}
+
+// Adds the list of known types to api.Scheme.
+func addKnownTypes(scheme *runtime.Scheme) error {
+	scheme.AddKnownTypes(SchemeGroupVersion,
+		&Stack{},
+		&StackList{},
+		&Owner{},
+	)
+	metav1.AddToGroupVersion(scheme, SchemeGroupVersion)
+	return nil
+}
+
+// Resource takes an unqualified resource and returns a Group qualified GroupResource
+func Resource(resource string) schema.GroupResource {
+	return SchemeGroupVersion.WithResource(resource).GroupResource()
+}

vendor/github.com/docker/compose-on-kubernetes/api/compose/v1beta1/stack.go

@@ -0,0 +1,87 @@
+package v1beta1
+
+import (
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+)
+
+// StackList defines a list of stacks
+type StackList struct {
+	metav1.TypeMeta `json:",inline"`
+	metav1.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
+
+	Items []Stack `json:"items" protobuf:"bytes,2,rep,name=items"`
+}
+
+// DeepCopyObject clones the stack list
+func (s *StackList) DeepCopyObject() runtime.Object {
+	if s == nil {
+		return nil
+	}
+	result := new(StackList)
+	result.TypeMeta = s.TypeMeta
+	result.ListMeta = s.ListMeta
+	if s.Items == nil {
+		return result
+	}
+	result.Items = make([]Stack, len(s.Items))
+	for ix, s := range s.Items {
+		result.Items[ix] = *s.clone()
+	}
+	return result
+}
+
+// Stack defines a stack object to be register in the kubernetes API
+type Stack struct {
+	metav1.TypeMeta   `json:",inline"`
+	metav1.ObjectMeta `json:"metadata,omitempty"`
+
+	Spec   StackSpec   `json:"spec,omitempty"`
+	Status StackStatus `json:"status,omitempty"`
+}
+
+// StackSpec defines the desired state of Stack
+type StackSpec struct {
+	ComposeFile string `json:"composeFile,omitempty"`
+}
+
+// StackPhase defines the status phase in which the stack is.
+type StackPhase string
+
+// These are valid conditions of a stack.
+const (
+	// StackAvailable means the stack is available.
+	StackAvailable StackPhase = "Available"
+	// StackProgressing means the deployment is progressing.
+	StackProgressing StackPhase = "Progressing"
+	// StackFailure is added in a stack when one of its members fails to be created
+	// or deleted.
+	StackFailure StackPhase = "Failure"
+)
+
+// StackStatus defines the observed state of Stack
+type StackStatus struct {
+	// Current condition of the stack.
+	Phase StackPhase `json:"phase,omitempty" protobuf:"bytes,1,opt,name=phase,casttype=StackPhase"`
+	// A human readable message indicating details about the stack.
+	Message string `json:"message,omitempty" protobuf:"bytes,5,opt,name=message"`
+}
+
+func (s *Stack) clone() *Stack {
+	if s == nil {
+		return nil
+	}
+	// in v1beta1, Stack has no pointer, slice or map. Plain old struct copy is ok
+	result := *s
+	return &result
+}
+
+// Clone implements the Cloner interface for kubernetes
+func (s *Stack) Clone() *Stack {
+	return s.clone()
+}
+
+// DeepCopyObject clones the stack
+func (s *Stack) DeepCopyObject() runtime.Object {
+	return s.clone()
+}