V2 types and TPR (#266)

This changes the core fission function, environment and trigger types. It also changes Fission's storage to use ThirdPartyResources.

 - Functions are now specified by packages. Functions can also have both source and deployment packages. A package can be specified by a literal, or by a URL.
 - Environments have a build and runtime component.
 - Triggers reference functions by a FunctionReference. This is a layer of indirection between triggers and functions, and will allow things like incremental function upgrades in future releases.

See Documentation/wip/env-v2.md for design discussion about points 1 and 2.

Changes:

* V2 Types

All types now have a spec, following the pattern of K8s objects.

Functions now have source and deployment packages. A Package can be
specified by literal, or by URL.

Environments now have a builder and runtime component.

All triggers use a new FunctionReference to specify the function. This
for now only uses a function name, but in the future can be extended
to be more flexible.

A new FunctionLoadRequest type is added for specialization requests to
the environment runtime.

* TPR types, TPR init code, and a "fission client"

Implements TPR types using the spec types in fission/types.go.

Adds code for adding creating TPR types, and convenient types for crud
operations on each of our resource types.

Adds code for connecting to K8s API and configuring a REST client with
fission types set up.

* Change old stateful controller into a thin apiserver

This apiserver is now simply a stateless api layer on top of the TPR
types. At the moment it doesn't do anything that couldn't be done by
simply talking to the TPR types. In the future we can have better
validation and potentially some higher level APIs (like versioning for
example) in here.

* Split controller client into files and update for v2 types.

* Update CLI for v2 types.

As far as possible we keep the CLI flags the same. We'll have to add
flags for source/deploy packages and builder/runtime
environments. That will come in the next change.

* Update poolmgr and fetcher for v2 types.

Also adds a poolmgr_test.

* Update router for new types.

Also adds a function reference resolver, which separates out the job
of resolving a FunctionReference to a function.

* Update kubewatcher and timer for v2 types.

* Update Message Queue trigger type for v2 types.

* Minor odds and ends.

* Fission bundle CLI updates

Remove controllerUrl flag, since we don't need it any more.

* Remove etcd deployment (replaced by storing state in TPR)

Also update the poolmgr commandline, and use an env var for the
fetcher image URL.

* Explicit ChecksumType and consts

* Clarify separation of environment interface types

fission/deployment.go

@@ -1,181 +0,0 @@
-/*
-Copyright 2016 The Fission Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package main
-
-import "fmt"
-
-func getDeploymentYaml() {
-	fmt.Printf(`
-apiVersion: v1
-kind: Namespace
-metadata:
-  name: fission
-  labels:
-    name: fission
-
----
-apiVersion: v1
-kind: Namespace
-metadata:
-  name: fission-function
-  labels:
-    name: fission-function
-
----
-apiVersion: v1
-kind: Service
-metadata:
-  name: controller
-  namespace: fission
-  labels:
-    svc: controller
-spec:
-  type: NodePort
-  ports:
-  - port: 80
-    targetPort: 8888
-    nodePort: 31313
-  selector:
-    svc: controller
-
----
-apiVersion: extensions/v1beta1
-kind: Deployment
-metadata:
-  name: controller
-  namespace: fission
-spec:
-  replicas: 1
-  template:
-    metadata: 
-      labels:
-        svc: controller
-    spec:
-      containers:
-      - name: controller
-        image: fission/fission-bundle
-        command: ["/fission-bundle"]
-        args: ["--controllerPort", "8888", "--filepath", "/filestore"]
-
----
-apiVersion: v1
-kind: Service
-metadata:
-  name: router
-  namespace: fission
-  labels:
-    svc: router
-spec:
-  type: NodePort
-  ports:
-  - port: 80
-    targetPort: 8888
-    nodePort: 31314
-  selector:
-    svc: router
-
----
-apiVersion: extensions/v1beta1
-kind: Deployment
-metadata:
-  name: router
-  namespace: fission
-spec:
-  replicas: 1
-  template:
-    metadata: 
-      labels:
-        svc: router
-    spec:
-      containers:
-      - name: router
-        image: fission/fission-bundle
-        command: ["/fission-bundle"]
-        args: ["--routerPort", "8888"]
-
----
-apiVersion: v1
-kind: Service
-metadata:
-  name: poolmgr
-  namespace: fission
-  labels:
-    svc: poolmgr
-spec:
-  ports:
-  - port: 80
-    targetPort: 8888
-  selector:
-    svc: poolmgr
-
----
-apiVersion: extensions/v1beta1
-kind: Deployment
-metadata:
-  name: poolmgr
-  namespace: fission
-spec:
-  replicas: 1
-  template:
-    metadata: 
-      labels:
-        svc: poolmgr
-    spec:
-      containers:
-      - name: poolmgr
-        image: fission/fission-bundle
-        command: ["/fission-bundle"]
-        args: ["--poolmgrPort", "8888"]
-
----
-apiVersion: v1
-kind: Service
-metadata:
-  name: etcd
-  namespace: fission
-  labels:
-    svc: etcd
-spec:
-  ports:
-  - port: 2379
-    targetPort: 2379
-  selector:
-    svc: etcd
-
----
-apiVersion: extensions/v1beta1
-kind: Deployment
-metadata:
-  name: etcd
-  namespace: fission
-spec:
-  replicas: 1
-  template:
-    metadata:
-      labels:
-        svc: etcd
-    spec:
-      containers:
-      - name: etcd
-        image: quay.io/coreos/etcd
-        env:
-        - name: ETCD_LISTEN_CLIENT_URLS
-          value: http://0.0.0.0:2379
-        - name: ETCD_ADVERTISE_CLIENT_URLS
-          value: http://etcd:2379
-`)
-}

fission/environment.go

@@ -22,8 +22,10 @@ import (
 	"text/tabwriter"
 
 	"github.com/urfave/cli"
+	"k8s.io/client-go/1.5/pkg/api"
 
 	"github.com/fission/fission"
+	"github.com/fission/fission/tpr"
 )
 
 func envCreate(c *cli.Context) error {
@@ -39,11 +41,17 @@ func envCreate(c *cli.Context) error {
 		fatal("Need an image, use --image.")
 	}
 
-	env := &fission.Environment{
-		Metadata: fission.Metadata{
-			Name: envName,
+	env := &tpr.Environment{
+		Metadata: api.ObjectMeta{
+			Name:      envName,
+			Namespace: api.NamespaceDefault,
+		},
+		Spec: fission.EnvironmentSpec{
+			Version: 1,
+			Runtime: fission.Runtime{
+				Image: envImg,
+			},
 		},
-		RunContainerImageUrl: envImg,
 	}
 
 	_, err := client.EnvironmentCreate(env)
@@ -61,14 +69,17 @@ func envGet(c *cli.Context) error {
 		fatal("Need a name, use --name.")
 	}
 
-	m := &fission.Metadata{Name: envName}
+	m := &api.ObjectMeta{
+		Name:      envName,
+		Namespace: api.NamespaceDefault,
+	}
 	env, err := client.EnvironmentGet(m)
 	checkErr(err, "get environment")
 
 	w := tabwriter.NewWriter(os.Stdout, 0, 0, 1, ' ', 0)
 	fmt.Fprintf(w, "%v\t%v\t%v\n", "NAME", "UID", "IMAGE")
 	fmt.Fprintf(w, "%v\t%v\t%v\n",
-		env.Metadata.Name, env.Metadata.Uid, env.RunContainerImageUrl)
+		env.Metadata.Name, env.Metadata.UID, env.Spec.Runtime.Image)
 	w.Flush()
 	return nil
 }
@@ -86,14 +97,15 @@ func envUpdate(c *cli.Context) error {
 		fatal("Need an image, use --image.")
 	}
 
-	env := &fission.Environment{
-		Metadata: fission.Metadata{
-			Name: envName,
-		},
-		RunContainerImageUrl: envImg,
-	}
+	env, err := client.EnvironmentGet(&api.ObjectMeta{
+		Name:      envName,
+		Namespace: api.NamespaceDefault,
+	})
+	checkErr(err, "find environment")
 
-	_, err := client.EnvironmentUpdate(env)
+	env.Spec.Runtime.Image = envImg
+
+	_, err = client.EnvironmentUpdate(env)
 	checkErr(err, "update environment")
 
 	fmt.Printf("environment '%v' updated\n", envName)
@@ -108,7 +120,10 @@ func envDelete(c *cli.Context) error {
 		fatal("Need a name , use --name.")
 	}
 
-	m := &fission.Metadata{Name: envName}
+	m := &api.ObjectMeta{
+		Name:      envName,
+		Namespace: api.NamespaceDefault,
+	}
 	err := client.EnvironmentDelete(m)
 	checkErr(err, "delete environment")
 
@@ -126,7 +141,7 @@ func envList(c *cli.Context) error {
 	fmt.Fprintf(w, "%v\t%v\t%v\n", "NAME", "UID", "IMAGE")
 	for _, env := range envs {
 		fmt.Fprintf(w, "%v\t%v\t%v\n",
-			env.Metadata.Name, env.Metadata.Uid, env.RunContainerImageUrl)
+			env.Metadata.Name, env.Metadata.UID, env.Spec.Runtime.Image)
 	}
 	w.Flush()
 

fission/function.go

@@ -20,45 +20,53 @@ import (
 	"context"
 	"fmt"
 	"io/ioutil"
-	"net/http"
+	//"net/http"
 	"os"
-	"os/exec"
-	"strings"
 	"text/tabwriter"
 	"time"
 
 	"github.com/satori/go.uuid"
 	"github.com/urfave/cli"
+	"k8s.io/client-go/1.5/pkg/api"
 
 	"github.com/fission/fission"
 	"github.com/fission/fission/fission/logdb"
+	"github.com/fission/fission/tpr"
 )
 
-func fnFetchCode(filePath string) []byte {
+func downloadUrl(url string) {
+	// var resp *http.Response
+	// resp, err := http.Get(url)
+	// if err != nil {
+	// 	checkErr(err, fmt.Sprintf("download function"))
+	// }
+
+	// defer resp.Body.Close()
+	// if resp.StatusCode != http.StatusOK {
+	// 	err = fmt.Errorf("%v - HTTP response returned non 200 status", resp.StatusCode)
+	// 	checkErr(err, fmt.Sprintf("download function"))
+	// }
+
+	// contents, err := ioutil.ReadAll(resp.Body)
+	// if err != nil {
+	// 	checkErr(err, fmt.Sprintf("download function body %v", url))
+	// }
+
+	// return
+}
+
+func fileSize(filePath string) int64 {
+	info, err := os.Stat(filePath)
+	checkErr(err, fmt.Sprintf("stat %v", filePath))
+	return info.Size()
+}
+
+func getPackageContents(filePath string) []byte {
 	var code []byte
 	var err error
 
-	if strings.HasPrefix(filePath, "http://") || strings.HasPrefix(filePath, "https://") {
-		var resp *http.Response
-		resp, err = http.Get(filePath)
-		if err != nil {
-			checkErr(err, fmt.Sprintf("download function"))
-		}
-
-		defer resp.Body.Close()
-		if resp.StatusCode != http.StatusOK {
-			err = fmt.Errorf("%v - HTTP response returned non 200 status", resp.StatusCode)
-			checkErr(err, fmt.Sprintf("download function"))
-		}
-
-		code, err = ioutil.ReadAll(resp.Body)
-		if err != nil {
-			checkErr(err, fmt.Sprintf("download function body %v", filePath))
-		}
-	} else {
-		code, err = ioutil.ReadFile(filePath)
-		checkErr(err, fmt.Sprintf("read %v", filePath))
-	}
+	code, err = ioutil.ReadFile(filePath)
+	checkErr(err, fmt.Sprintf("read %v", filePath))
 	return code
 }
 
@@ -83,12 +91,25 @@ func fnCreate(c *cli.Context) error {
 		}
 	}
 
-	code := fnFetchCode(fileName)
+	if fileSize(fileName) > fission.PackageLiteralSizeLimit {
+		// TODO fallback to uploading + setting a Package URL
+		fmt.Printf("File size not supported yet")
+		os.Exit(1)
+	}
 
-	function := &fission.Function{
-		Metadata:    fission.Metadata{Name: fnName},
-		Environment: fission.Metadata{Name: envName},
-		Code:        string(code),
+	pkgContents := getPackageContents(fileName)
+
+	function := &tpr.Function{
+		Metadata: api.ObjectMeta{
+			Name:      fnName,
+			Namespace: api.NamespaceDefault,
+		},
+		Spec: fission.FunctionSpec{
+			EnvironmentName: envName,
+			Deployment: fission.Package{
+				Literal: pkgContents,
+			},
+		},
 	}
 
 	_, err := client.FunctionCreate(function)
@@ -106,14 +127,18 @@ func fnCreate(c *cli.Context) error {
 		method = "GET"
 	}
 	triggerName := uuid.NewV4().String()
-	ht := &fission.HTTPTrigger{
-		Metadata: fission.Metadata{
-			Name: triggerName,
+	ht := &tpr.Httptrigger{
+		Metadata: api.ObjectMeta{
+			Name:      triggerName,
+			Namespace: api.NamespaceDefault,
 		},
-		UrlPattern: triggerUrl,
-		Method:     getMethod(method),
-		Function: fission.Metadata{
-			Name: fnName,
+		Spec: fission.HTTPTriggerSpec{
+			RelativeURL: triggerUrl,
+			Method:      getMethod(method),
+			FunctionReference: fission.FunctionReference{
+				Type: fission.FunctionReferenceTypeFunctionName,
+				Name: fnName,
+			},
 		},
 	}
 	_, err = client.HTTPTriggerCreate(ht)
@@ -130,13 +155,15 @@ func fnGet(c *cli.Context) error {
 	if len(fnName) == 0 {
 		fatal("Need name of function, use --name")
 	}
-	fnUid := c.String("uid")
-	m := &fission.Metadata{Name: fnName, Uid: fnUid}
+	m := &api.ObjectMeta{
+		Name:      fnName,
+		Namespace: api.NamespaceDefault,
+	}
 
-	code, err := client.FunctionGetRaw(m)
+	code, err := client.FunctionGetRawDeployment(m)
 	checkErr(err, "get function")
 
-	fmt.Println(string(code))
+	os.Stdout.Write(code)
 	return err
 }
 
@@ -148,8 +175,10 @@ func fnGetMeta(c *cli.Context) error {
 		fatal("Need name of function, use --name")
 	}
 
-	fnUid := c.String("uid")
-	m := &fission.Metadata{Name: fnName, Uid: fnUid}
+	m := &api.ObjectMeta{
+		Name:      fnName,
+		Namespace: api.NamespaceDefault,
+	}
 
 	f, err := client.FunctionGet(m)
 	checkErr(err, "get function")
@@ -157,7 +186,7 @@ func fnGetMeta(c *cli.Context) error {
 	w := tabwriter.NewWriter(os.Stdout, 0, 0, 1, ' ', 0)
 	fmt.Fprintf(w, "%v\t%v\t%v\n", "NAME", "UID", "ENV")
 	fmt.Fprintf(w, "%v\t%v\t%v\n",
-		f.Metadata.Name, f.Metadata.Uid, f.Environment.Name)
+		f.Metadata.Name, f.Metadata.UID, f.Spec.EnvironmentName)
 	w.Flush()
 	return err
 }
@@ -170,14 +199,13 @@ func fnUpdate(c *cli.Context) error {
 		fatal("Need name of function, use --name")
 	}
 
-	function, err := client.FunctionGet(&fission.Metadata{Name: fnName})
+	function, err := client.FunctionGet(&api.ObjectMeta{
+		Name:      fnName,
+		Namespace: api.NamespaceDefault,
+	})
 	checkErr(err, fmt.Sprintf("read function '%v'", fnName))
 
 	envName := c.String("env")
-	if len(envName) > 0 {
-		function.Environment.Name = envName
-	}
-
 	fileName := c.String("code")
 	if len(fileName) == 0 {
 		fileName = c.String("package")
@@ -188,8 +216,16 @@ func fnUpdate(c *cli.Context) error {
 	}
 
 	if len(fileName) > 0 {
-		code := fnFetchCode(fileName)
-		function.Code = string(code)
+		if fileSize(fileName) > fission.PackageLiteralSizeLimit {
+			// TODO fallback to uploading + setting a Package URL
+			fmt.Printf("File size >256k not supported yet")
+			os.Exit(1)
+		}
+
+		function.Spec.Deployment.Literal = getPackageContents(fileName)
+	}
+	if len(envName) > 0 {
+		function.Spec.EnvironmentName = envName
 	}
 
 	_, err = client.FunctionUpdate(function)
@@ -207,8 +243,10 @@ func fnDelete(c *cli.Context) error {
 		fatal("Need name of function, use --name")
 	}
 
-	fnUid := c.String("uid")
-	m := &fission.Metadata{Name: fnName, Uid: fnUid}
+	m := &api.ObjectMeta{
+		Name:      fnName,
+		Namespace: api.NamespaceDefault,
+	}
 
 	err := client.FunctionDelete(m)
 	checkErr(err, fmt.Sprintf("delete function '%v'", fnName))
@@ -228,65 +266,13 @@ func fnList(c *cli.Context) error {
 	fmt.Fprintf(w, "%v\t%v\t%v\n", "NAME", "UID", "ENV")
 	for _, f := range fns {
 		fmt.Fprintf(w, "%v\t%v\t%v\n",
-			f.Metadata.Name, f.Metadata.Uid, f.Environment.Name)
+			f.Metadata.Name, f.Metadata.UID, f.Spec.EnvironmentName)
 	}
 	w.Flush()
 
 	return err
 }
 
-func fnEdit(c *cli.Context) error {
-	client := getClient(c.GlobalString("server"))
-
-	fnName := c.String("name")
-	if len(fnName) == 0 {
-		fatal("Need name of function, use --name")
-	}
-	fnUid := c.String("uid")
-
-	// get function meta
-	function, err := client.FunctionGet(&fission.Metadata{Name: fnName, Uid: fnUid})
-	checkErr(err, fmt.Sprintf("read function '%v'", fnName))
-
-	// write to tmp file
-	tmpFile, err := ioutil.TempFile("", fnName)
-	checkErr(err, "create temp file")
-	defer os.Remove(tmpFile.Name())
-
-	_, err = tmpFile.Write([]byte(function.Code))
-	checkErr(err, "write temp file")
-	tmpFile.Close()
-
-	// invoke $EDITOR on tmp file and wait for it
-	editor := os.Getenv("EDITOR")
-	if len(editor) == 0 {
-		editor = "vi"
-	}
-	cmd := exec.Command("/bin/sh", "-c", fmt.Sprintf("%v %v", editor, tmpFile.Name()))
-	cmd.Stdin = os.Stdin
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-
-	err = cmd.Start()
-	checkErr(err, "start editor")
-
-	err = cmd.Wait()
-	checkErr(err, "wait for editor")
-
-	// read new code out of the file
-	contents, err := ioutil.ReadFile(tmpFile.Name())
-	checkErr(err, "read temp file")
-
-	function.Code = string(contents)
-
-	// upload the updated function
-	newfn, err := client.FunctionUpdate(function)
-	checkErr(err, "upload edited function")
-
-	fmt.Printf("function %v updated, new uuid: %v\n", newfn.Name, newfn.Uid)
-	return nil
-}
-
 func fnLogs(c *cli.Context) error {
 	client := getClient(c.GlobalString("server"))
 
@@ -301,13 +287,15 @@ func fnLogs(c *cli.Context) error {
 	}
 
 	fnPod := c.String("pod")
-	m := &fission.Metadata{Name: fnName}
+	m := &api.ObjectMeta{
+		Name:      fnName,
+		Namespace: api.NamespaceDefault,
+	}
 
 	f, err := client.FunctionGet(m)
 	checkErr(err, "get function")
 
-	// client first send db query to controller, then controller will
-	// establishe a proxy server that bridges the client and the database.
+	// request the controller to establish a proxy server to the database.
 	logDB, err := logdb.GetLogDB(dbType, c.GlobalString("server"))
 	if err != nil {
 		fatal("failed to connect log database")
@@ -325,7 +313,7 @@ func fnLogs(c *cli.Context) error {
 				logFilter := logdb.LogFilter{
 					Pod:      fnPod,
 					Function: f.Metadata.Name,
-					FuncUid:  f.Metadata.Uid,
+					FuncUid:  string(f.Metadata.UID),
 					Since:    t,
 				}
 				logEntries, err := logDB.GetLogs(logFilter)
@@ -372,7 +360,7 @@ func fnPods(c *cli.Context) error {
 		dbType = logdb.INFLUXDB
 	}
 
-	m := &fission.Metadata{Name: fnName}
+	m := &api.ObjectMeta{Name: fnName}
 
 	f, err := client.FunctionGet(m)
 	checkErr(err, "get function")
@@ -386,7 +374,7 @@ func fnPods(c *cli.Context) error {
 
 	logFilter := logdb.LogFilter{
 		Function: f.Metadata.Name,
-		FuncUid:  f.Metadata.Uid,
+		FuncUid:  string(f.Metadata.UID),
 	}
 	pods, err := logDB.GetPods(logFilter)
 	if err != nil {

fission/httptrigger.go

@@ -25,8 +25,10 @@ import (
 
 	"github.com/satori/go.uuid"
 	"github.com/urfave/cli"
+	"k8s.io/client-go/1.5/pkg/api"
 
 	"github.com/fission/fission"
+	"github.com/fission/fission/tpr"
 )
 
 // returns one of http.Method*
@@ -62,7 +64,6 @@ func htCreate(c *cli.Context) error {
 	if len(fnName) == 0 {
 		fatal("Need a function name to create a trigger, use --function")
 	}
-	fnUid := c.String("uid")
 	triggerUrl := c.String("url")
 	if len(triggerUrl) == 0 {
 		fatal("Need a trigger URL, use --url")
@@ -75,15 +76,18 @@ func htCreate(c *cli.Context) error {
 	// just name triggers by uuid.
 	triggerName := uuid.NewV4().String()
 
-	ht := &fission.HTTPTrigger{
-		Metadata: fission.Metadata{
-			Name: triggerName,
+	ht := &tpr.Httptrigger{
+		Metadata: api.ObjectMeta{
+			Name:      triggerName,
+			Namespace: api.NamespaceDefault,
 		},
-		UrlPattern: triggerUrl,
-		Method:     getMethod(method),
-		Function: fission.Metadata{
-			Name: fnName,
-			Uid:  fnUid,
+		Spec: fission.HTTPTriggerSpec{
+			RelativeURL: triggerUrl,
+			Method:      getMethod(method),
+			FunctionReference: fission.FunctionReference{
+				Type: fission.FunctionReferenceTypeFunctionName,
+				Name: fnName,
+			},
 		},
 	}
 
@@ -105,11 +109,21 @@ func htUpdate(c *cli.Context) error {
 		fatal("Need name of trigger, use --name")
 	}
 
-	ht, err := client.HTTPTriggerGet(&fission.Metadata{Name: htName})
+	// update function ref
+	newFn := c.String("function")
+	if len(newFn) == 0 {
+		fatal("Nothing to update. Use --function to specify a new function.")
+	}
+
+	ht, err := client.HTTPTriggerGet(&api.ObjectMeta{
+		Name:      htName,
+		Namespace: api.NamespaceDefault,
+	})
 	checkErr(err, "get HTTP trigger")
 
-	newUid := c.String("uid")
-	ht.Function.Uid = newUid
+	if len(newFn) > 0 {
+		ht.Spec.FunctionReference.Name = newFn
+	}
 
 	_, err = client.HTTPTriggerUpdate(ht)
 	checkErr(err, "update HTTP trigger")
@@ -125,7 +139,10 @@ func htDelete(c *cli.Context) error {
 		fatal("Need name of trigger to delete, use --name")
 	}
 
-	err := client.HTTPTriggerDelete(&fission.Metadata{Name: htName})
+	err := client.HTTPTriggerDelete(&api.ObjectMeta{
+		Name:      htName,
+		Namespace: api.NamespaceDefault,
+	})
 	checkErr(err, "delete trigger")
 
 	fmt.Printf("trigger '%v' deleted\n", htName)
@@ -140,10 +157,10 @@ func htList(c *cli.Context) error {
 
 	w := tabwriter.NewWriter(os.Stdout, 0, 0, 1, ' ', 0)
 
-	fmt.Fprintf(w, "%v\t%v\t%v\t%v\t%v\n", "NAME", "METHOD", "URL", "FUNCTION_NAME", "FUNCTION_UID")
+	fmt.Fprintf(w, "%v\t%v\t%v\t%v\n", "NAME", "METHOD", "URL", "FUNCTION_NAME")
 	for _, ht := range hts {
-		fmt.Fprintf(w, "%v\t%v\t%v\t%v\t%v\n",
-			ht.Metadata.Name, ht.Method, ht.UrlPattern, ht.Function.Name, ht.Function.Uid)
+		fmt.Fprintf(w, "%v\t%v\t%v\t%v\n",
+			ht.Metadata.Name, ht.Spec.Method, ht.Spec.RelativeURL, ht.Spec.FunctionReference.Name)
 	}
 	w.Flush()
 

fission/main.go

@@ -40,18 +40,16 @@ func main() {
 	fnEnvNameFlag := cli.StringFlag{Name: "env", Usage: "environment name for function"}
 	fnCodeFlag := cli.StringFlag{Name: "code", Usage: "local path or URL for source code"}
 	fnPackageFlag := cli.StringFlag{Name: "package", Usage: "local path or URL for binary package"}
-	fnUidFlag := cli.StringFlag{Name: "uid", Usage: "function uid, optional (use latest if unspecified)"}
 	fnPodFlag := cli.StringFlag{Name: "pod", Usage: "function pod name, optional (use latest if unspecified)"}
 	fnFollowFlag := cli.BoolFlag{Name: "follow, f", Usage: "specify if the logs should be streamed"}
 	fnDetailFlag := cli.BoolFlag{Name: "detail, d", Usage: "display detailed information"}
 	fnLogDBTypeFlag := cli.StringFlag{Name: "dbtype", Usage: "log database type, e.g. influxdb (currently only influxdb is supported)"}
 	fnSubcommands := []cli.Command{
 		{Name: "create", Usage: "Create new function (and optionally, an HTTP route to it)", Flags: []cli.Flag{fnNameFlag, fnEnvNameFlag, fnCodeFlag, fnPackageFlag, htUrlFlag, htMethodFlag}, Action: fnCreate},
-		{Name: "get", Usage: "Get function source code", Flags: []cli.Flag{fnNameFlag, fnUidFlag}, Action: fnGet},
-		{Name: "edit", Usage: "Edit function source code in $EDITOR", Flags: []cli.Flag{fnNameFlag, fnUidFlag}, Action: fnEdit},
-		{Name: "getmeta", Usage: "Get function metadata", Flags: []cli.Flag{fnNameFlag, fnUidFlag}, Action: fnGetMeta},
+		{Name: "get", Usage: "Get function source code", Flags: []cli.Flag{fnNameFlag}, Action: fnGet},
+		{Name: "getmeta", Usage: "Get function metadata", Flags: []cli.Flag{fnNameFlag}, Action: fnGetMeta},
 		{Name: "update", Usage: "Update function source code", Flags: []cli.Flag{fnNameFlag, fnEnvNameFlag, fnCodeFlag, fnPackageFlag}, Action: fnUpdate},
-		{Name: "delete", Usage: "Delete function", Flags: []cli.Flag{fnNameFlag, fnUidFlag}, Action: fnDelete},
+		{Name: "delete", Usage: "Delete function", Flags: []cli.Flag{fnNameFlag}, Action: fnDelete},
 		{Name: "list", Usage: "List all functions", Flags: []cli.Flag{}, Action: fnList},
 		{Name: "logs", Usage: "Display function logs", Flags: []cli.Flag{fnNameFlag, fnPodFlag, fnFollowFlag, fnDetailFlag, fnLogDBTypeFlag}, Action: fnLogs},
 		{Name: "pods", Usage: "Display function pods", Flags: []cli.Flag{fnNameFlag, fnLogDBTypeFlag}, Action: fnPods},
@@ -60,11 +58,10 @@ func main() {
 	// httptriggers
 	htNameFlag := cli.StringFlag{Name: "name", Usage: "HTTP Trigger name"}
 	htFnNameFlag := cli.StringFlag{Name: "function", Usage: "Function name"}
-	htFnUidFlag := cli.StringFlag{Name: "uid", Usage: "Function UID (optional; uses latest if unspecified)"}
 	htSubcommands := []cli.Command{
-		{Name: "create", Aliases: []string{"add"}, Usage: "Create HTTP trigger", Flags: []cli.Flag{htMethodFlag, htUrlFlag, htFnNameFlag, htFnUidFlag}, Action: htCreate},
+		{Name: "create", Aliases: []string{"add"}, Usage: "Create HTTP trigger", Flags: []cli.Flag{htMethodFlag, htUrlFlag, htFnNameFlag}, Action: htCreate},
 		{Name: "get", Usage: "Get HTTP trigger", Flags: []cli.Flag{htMethodFlag, htUrlFlag}, Action: htGet},
-		{Name: "update", Usage: "Update HTTP trigger", Flags: []cli.Flag{htNameFlag, htFnNameFlag, htFnUidFlag}, Action: htUpdate},
+		{Name: "update", Usage: "Update HTTP trigger", Flags: []cli.Flag{htNameFlag, htFnNameFlag}, Action: htUpdate},
 		{Name: "delete", Usage: "Delete HTTP trigger", Flags: []cli.Flag{htNameFlag}, Action: htDelete},
 		{Name: "list", Usage: "List HTTP triggers", Flags: []cli.Flag{}, Action: htList},
 	}
@@ -73,11 +70,10 @@ func main() {
 	ttNameFlag := cli.StringFlag{Name: "name", Usage: "Time Trigger name"}
 	ttCronFlag := cli.StringFlag{Name: "cron", Usage: "Time Trigger cron spec ('0 30 * * *', '@every 5m', '@hourly')"}
 	ttFnNameFlag := cli.StringFlag{Name: "function", Usage: "Function name"}
-	ttFnUidFlag := cli.StringFlag{Name: "uid", Usage: "Function UID (optional; uses latest if unspecified)"}
 	ttSubcommands := []cli.Command{
-		{Name: "create", Aliases: []string{"add"}, Usage: "Create Time trigger", Flags: []cli.Flag{ttNameFlag, ttFnNameFlag, ttFnUidFlag, ttCronFlag}, Action: ttCreate},
+		{Name: "create", Aliases: []string{"add"}, Usage: "Create Time trigger", Flags: []cli.Flag{ttNameFlag, ttFnNameFlag, ttCronFlag}, Action: ttCreate},
 		{Name: "get", Usage: "Get Time trigger", Flags: []cli.Flag{}, Action: ttGet},
-		{Name: "update", Usage: "Update Time trigger", Flags: []cli.Flag{ttNameFlag, ttCronFlag}, Action: ttUpdate},
+		{Name: "update", Usage: "Update Time trigger", Flags: []cli.Flag{ttNameFlag, ttCronFlag, ttFnNameFlag}, Action: ttUpdate},
 		{Name: "delete", Usage: "Delete Time trigger", Flags: []cli.Flag{ttNameFlag}, Action: ttDelete},
 		{Name: "list", Usage: "List Time triggers", Flags: []cli.Flag{}, Action: ttList},
 	}
@@ -85,14 +81,13 @@ func main() {
 	// Message queue trigger
 	mqtNameFlag := cli.StringFlag{Name: "name", Usage: "Message queue Trigger name"}
 	mqtFnNameFlag := cli.StringFlag{Name: "function", Usage: "Function name"}
-	mqtFnUidFlag := cli.StringFlag{Name: "uid", Usage: "Function UID (optional; uses latest if unspecified)"}
 	mqtMQTypeFlag := cli.StringFlag{Name: "mqtype", Usage: "Message queue type, e.g. nats-streaming  (optional; uses \"nats-streaming\" if unspecified)"}
 	mqtTopicFlag := cli.StringFlag{Name: "topic", Usage: "Message queue Topic the trigger listens on"}
 	mqtRespTopicFlag := cli.StringFlag{Name: "resptopic", Usage: "Topic that the function response is sent on (optional; response discarded if unspecified)"}
 	mqtSubcommands := []cli.Command{
-		{Name: "create", Aliases: []string{"add"}, Usage: "Create Message queue trigger", Flags: []cli.Flag{mqtNameFlag, mqtFnNameFlag, mqtFnUidFlag, mqtMQTypeFlag, mqtTopicFlag, mqtRespTopicFlag}, Action: mqtCreate},
+		{Name: "create", Aliases: []string{"add"}, Usage: "Create Message queue trigger", Flags: []cli.Flag{mqtNameFlag, mqtFnNameFlag, mqtMQTypeFlag, mqtTopicFlag, mqtRespTopicFlag}, Action: mqtCreate},
 		{Name: "get", Usage: "Get message queue trigger", Flags: []cli.Flag{}, Action: mqtGet},
-		{Name: "update", Usage: "Update message queue trigger", Flags: []cli.Flag{mqtNameFlag, mqtTopicFlag, mqtRespTopicFlag}, Action: mqtUpdate},
+		{Name: "update", Usage: "Update message queue trigger", Flags: []cli.Flag{mqtNameFlag, mqtTopicFlag, mqtRespTopicFlag, mqtFnNameFlag}, Action: mqtUpdate},
 		{Name: "delete", Usage: "Delete message queue trigger", Flags: []cli.Flag{mqtNameFlag}, Action: mqtDelete},
 		{Name: "list", Usage: "List message queue triggers", Flags: []cli.Flag{mqtMQTypeFlag}, Action: mqtList},
 	}
@@ -111,12 +106,11 @@ func main() {
 	// watches
 	wNameFlag := cli.StringFlag{Name: "name", Usage: "Watch name"}
 	wFnNameFlag := cli.StringFlag{Name: "function", Usage: "Function name"}
-	wFnUidFlag := cli.StringFlag{Name: "uid", Usage: "Function UID (optional; uses latest if unspecified)"}
 	wNamespaceFlag := cli.StringFlag{Name: "ns", Usage: "Namespace of resource to watch"}
 	wObjTypeFlag := cli.StringFlag{Name: "type", Usage: "Type of resource to watch (Pod, Service, etc.)"}
 	wLabelsFlag := cli.StringFlag{Name: "labels", Usage: "Label selector of the form a=b,c=d"}
 	wSubCommands := []cli.Command{
-		{Name: "create", Aliases: []string{"add"}, Usage: "Create a watch", Flags: []cli.Flag{wFnNameFlag, wFnUidFlag, wNamespaceFlag, wObjTypeFlag, wLabelsFlag}, Action: wCreate},
+		{Name: "create", Aliases: []string{"add"}, Usage: "Create a watch", Flags: []cli.Flag{wFnNameFlag, wNamespaceFlag, wObjTypeFlag, wLabelsFlag}, Action: wCreate},
 		{Name: "get", Usage: "Get details about a watch", Flags: []cli.Flag{wNameFlag}, Action: wGet},
 		// TODO add update flag when supported
 		{Name: "delete", Usage: "Delete watch", Flags: []cli.Flag{wNameFlag}, Action: wDelete},
@@ -130,16 +124,6 @@ func main() {
 		{Name: "mqtrigger", Aliases: []string{"mqt", "messagequeue"}, Usage: "Manage message queue triggers for functions", Subcommands: mqtSubcommands},
 		{Name: "environment", Aliases: []string{"env"}, Usage: "Manage environments", Subcommands: envSubcommands},
 		{Name: "watch", Aliases: []string{"w"}, Usage: "Manage watches", Subcommands: wSubCommands},
-
-		// Misc commands
-		{
-			Name:  "get-deployment-yaml",
-			Usage: "Get deployment yaml.  Use it as 'fission get-deployment-yaml | kubectl create -f -'",
-			Action: func(c *cli.Context) error {
-				getDeploymentYaml()
-				return nil
-			},
-		},
 	}
 
 	app.Run(os.Args)

fission/mqtrigger.go

@@ -23,9 +23,11 @@ import (
 
 	"github.com/satori/go.uuid"
 	"github.com/urfave/cli"
+	"k8s.io/client-go/1.5/pkg/api"
 
 	"github.com/fission/fission"
 	"github.com/fission/fission/mqtrigger/messageQueue"
+	"github.com/fission/fission/tpr"
 )
 
 func mqtCreate(c *cli.Context) error {
@@ -39,7 +41,7 @@ func mqtCreate(c *cli.Context) error {
 	if len(fnName) == 0 {
 		fatal("Need a function name to create a trigger, use --function")
 	}
-	fnUid := c.String("uid")
+
 	mqType := c.String("mqtype")
 	switch mqType {
 	case "":
@@ -58,24 +60,27 @@ func mqtCreate(c *cli.Context) error {
 	respTopic := c.String("resptopic")
 
 	if topic == respTopic {
+		// TODO maybe this should just be a warning, perhaps
+		// allow it behind a --force flag
 		fatal("Listen topic should not equal to response topic")
 	}
 
 	checkMQTopicAvailability(mqType, topic, respTopic)
 
-	fnMeta := fission.Metadata{
-		Name: fnName,
-		Uid:  fnUid,
-	}
-
-	mqt := fission.MessageQueueTrigger{
-		Metadata: fission.Metadata{
-			Name: mqtName,
+	mqt := tpr.Messagequeuetrigger{
+		Metadata: api.ObjectMeta{
+			Name:      mqtName,
+			Namespace: api.NamespaceDefault,
+		},
+		Spec: fission.MessageQueueTriggerSpec{
+			FunctionReference: fission.FunctionReference{
+				Type: fission.FunctionReferenceTypeFunctionName,
+				Name: fnName,
+			},
+			MessageQueueType: mqType,
+			Topic:            topic,
+			ResponseTopic:    respTopic,
 		},
-		Function:         fnMeta,
-		MessageQueueType: mqType,
-		Topic:            topic,
-		ResponseTopic:    respTopic,
 	}
 
 	_, err := client.MessageQueueTriggerCreate(&mqt)
@@ -97,14 +102,33 @@ func mqtUpdate(c *cli.Context) error {
 	}
 	topic := c.String("topic")
 	respTopic := c.String("resptopic")
+	fnName := c.String("function")
 
-	mqt, err := client.MessageQueueTriggerGet(&fission.Metadata{Name: mqtName})
+	mqt, err := client.MessageQueueTriggerGet(&api.ObjectMeta{
+		Name:      mqtName,
+		Namespace: api.NamespaceDefault,
+	})
 	checkErr(err, "get Time trigger")
 
-	checkMQTopicAvailability(mqt.MessageQueueType, topic, respTopic)
+	checkMQTopicAvailability(mqt.Spec.MessageQueueType, topic, respTopic)
 
-	mqt.Topic = topic
-	mqt.ResponseTopic = respTopic
+	updated := false
+	if len(topic) > 0 {
+		mqt.Spec.Topic = topic
+		updated = true
+	}
+	if len(respTopic) > 0 {
+		mqt.Spec.ResponseTopic = respTopic
+		updated = true
+	}
+	if len(fnName) > 0 {
+		mqt.Spec.FunctionReference.Name = fnName
+		updated = true
+	}
+
+	if !updated {
+		fatal("Nothing to update. Use --topic, --resptopic, or --function.")
+	}
 
 	_, err = client.MessageQueueTriggerUpdate(mqt)
 	checkErr(err, "update Time trigger")
@@ -120,7 +144,10 @@ func mqtDelete(c *cli.Context) error {
 		fatal("Need name of trigger to delete, use --name")
 	}
 
-	err := client.MessageQueueTriggerDelete(&fission.Metadata{Name: mqtName})
+	err := client.MessageQueueTriggerDelete(&api.ObjectMeta{
+		Name:      mqtName,
+		Namespace: api.NamespaceDefault,
+	})
 	checkErr(err, "delete trigger")
 
 	fmt.Printf("trigger '%v' deleted\n", mqtName)
@@ -135,11 +162,11 @@ func mqtList(c *cli.Context) error {
 
 	w := tabwriter.NewWriter(os.Stdout, 0, 0, 1, ' ', 0)
 
-	fmt.Fprintf(w, "%v\t%v\t%v\t%v\t%v\t%v\n",
-		"NAME", "FUNCTION_NAME", "FUNCTION_UID", "MESSAGE_QUEUE_TYPE", "TOPIC", "RESPONSE_TOPIC")
+	fmt.Fprintf(w, "%v\t%v\t%v\t%v\t%v\n",
+		"NAME", "FUNCTION_NAME", "MESSAGE_QUEUE_TYPE", "TOPIC", "RESPONSE_TOPIC")
 	for _, mqt := range mqts {
-		fmt.Fprintf(w, "%v\t%v\t%v\t%v\t%v\t%v\n",
-			mqt.Metadata.Name, mqt.Function.Name, mqt.Function.Uid, mqt.MessageQueueType, mqt.Topic, mqt.ResponseTopic)
+		fmt.Fprintf(w, "%v\t%v\t%v\t%v\t%v\n",
+			mqt.Metadata.Name, mqt.Spec.FunctionReference.Name, mqt.Spec.MessageQueueType, mqt.Spec.Topic, mqt.Spec.ResponseTopic)
 	}
 	w.Flush()
 

fission/timetrigger.go

@@ -23,8 +23,10 @@ import (
 
 	"github.com/satori/go.uuid"
 	"github.com/urfave/cli"
+	"k8s.io/client-go/1.5/pkg/api"
 
 	"github.com/fission/fission"
+	"github.com/fission/fission/tpr"
 )
 
 func ttCreate(c *cli.Context) error {
@@ -38,20 +40,22 @@ func ttCreate(c *cli.Context) error {
 	if len(fnName) == 0 {
 		fatal("Need a function name to create a trigger, use --function")
 	}
-	fnUid := c.String("uid")
 	cron := c.String("cron")
 	if len(cron) == 0 {
-		fatal("Need a cron spec like '0 30 * * *', '@every 1h30m', '@hourly', use --cron")
+		fatal("Need a cron spec like '0 30 * * *', '@every 1h30m', or '@hourly'; use --cron")
 	}
 
-	tt := &fission.TimeTrigger{
-		Metadata: fission.Metadata{
-			Name: name,
+	tt := &tpr.Timetrigger{
+		Metadata: api.ObjectMeta{
+			Name:      name,
+			Namespace: api.NamespaceDefault,
 		},
-		Cron: cron,
-		Function: fission.Metadata{
-			Name: fnName,
-			Uid:  fnUid,
+		Spec: fission.TimeTriggerSpec{
+			Cron: cron,
+			FunctionReference: fission.FunctionReference{
+				Type: fission.FunctionReferenceTypeFunctionName,
+				Name: fnName,
+			},
 		},
 	}
 
@@ -73,12 +77,26 @@ func ttUpdate(c *cli.Context) error {
 		fatal("Need name of trigger, use --name")
 	}
 
-	tt, err := client.TimeTriggerGet(&fission.Metadata{Name: ttName})
-	checkErr(err, "get Time trigger")
+	tt, err := client.TimeTriggerGet(&api.ObjectMeta{
+		Name:      ttName,
+		Namespace: api.NamespaceDefault,
+	})
+	checkErr(err, "get time trigger")
 
+	updated := false
 	newCron := c.String("cron")
 	if len(newCron) != 0 {
-		tt.Cron = newCron
+		tt.Spec.Cron = newCron
+		updated = true
+	}
+	fnName := c.String("function")
+	if len(fnName) > 0 {
+		tt.Spec.FunctionReference.Name = fnName
+		updated = true
+	}
+
+	if !updated {
+		fatal("Nothing to update. Use --cron or --function.")
 	}
 
 	_, err = client.TimeTriggerUpdate(tt)
@@ -95,7 +113,10 @@ func ttDelete(c *cli.Context) error {
 		fatal("Need name of trigger to delete, use --name")
 	}
 
-	err := client.TimeTriggerDelete(&fission.Metadata{Name: ttName})
+	err := client.TimeTriggerDelete(&api.ObjectMeta{
+		Name:      ttName,
+		Namespace: api.NamespaceDefault,
+	})
 	checkErr(err, "delete trigger")
 
 	fmt.Printf("trigger '%v' deleted\n", ttName)
@@ -110,11 +131,10 @@ func ttList(c *cli.Context) error {
 
 	w := tabwriter.NewWriter(os.Stdout, 0, 0, 1, ' ', 0)
 
-	fmt.Fprintf(w, "%v\t%v\t%v\t%v\n",
-		"NAME", "CRON", "FUNCTION_NAME", "FUNCTION_UID")
+	fmt.Fprintf(w, "%v\t%v\t%v\n", "NAME", "CRON", "FUNCTION_NAME")
 	for _, tt := range tts {
 		fmt.Fprintf(w, "%v\t%v\t%v\t%v\n",
-			tt.Metadata.Name, tt.Cron, tt.Function.Name, tt.Function.Uid)
+			tt.Metadata.Name, tt.Spec.Cron, tt.Spec.FunctionReference.Name)
 	}
 	w.Flush()
 

fission/watch.go

@@ -23,8 +23,10 @@ import (
 
 	"github.com/satori/go.uuid"
 	"github.com/urfave/cli"
+	"k8s.io/client-go/1.5/pkg/api"
 
 	"github.com/fission/fission"
+	"github.com/fission/fission/tpr"
 )
 
 func wCreate(c *cli.Context) error {
@@ -34,7 +36,6 @@ func wCreate(c *cli.Context) error {
 	if len(fnName) == 0 {
 		fatal("Need a function name to create a watch, use --function")
 	}
-	fnUid := c.String("uid")
 
 	namespace := c.String("ns")
 	if len(namespace) == 0 {
@@ -52,23 +53,28 @@ func wCreate(c *cli.Context) error {
 	// empty 'labels' selects everything
 	if len(labels) == 0 {
 		fmt.Printf("Watching all objects of type '%v', use --labels to refine selection.\n", objType)
+	} else {
+		// TODO
+		fmt.Printf("Label selector not implemented, watching all objects")
 	}
 
 	// automatically name watches
 	watchName := uuid.NewV4().String()
 
-	w := &fission.Watch{
-		Metadata: fission.Metadata{
-			Name: watchName,
+	w := &tpr.Kuberneteswatchtrigger{
+		Metadata: api.ObjectMeta{
+			Name:      watchName,
+			Namespace: api.NamespaceDefault,
 		},
-		Function: fission.Metadata{
-			Name: fnName,
-			Uid:  fnUid,
+		Spec: fission.KubernetesWatchTriggerSpec{
+			Namespace: namespace,
+			Type:      objType,
+			//LabelSelector: labels,
+			FunctionReference: fission.FunctionReference{
+				Name: fnName,
+				Type: fission.FunctionReferenceTypeFunctionName,
+			},
 		},
-		Namespace:     namespace,
-		ObjType:       objType,
-		LabelSelector: labels,
-		FieldSelector: "", // TODO
 	}
 
 	_, err := client.WatchCreate(w)
@@ -79,10 +85,14 @@ func wCreate(c *cli.Context) error {
 }
 
 func wGet(c *cli.Context) error {
+	// TODO
+	fatal("Not implemented")
 	return nil
 }
 
 func wUpdate(c *cli.Context) error {
+	// TODO
+	fatal("Not implemented")
 	return nil
 }
 
@@ -94,7 +104,10 @@ func wDelete(c *cli.Context) error {
 		fatal("Need name of watch to delete, use --name")
 	}
 
-	err := client.WatchDelete(&fission.Metadata{Name: wName})
+	err := client.WatchDelete(&api.ObjectMeta{
+		Name:      wName,
+		Namespace: api.NamespaceDefault,
+	})
 	checkErr(err, "delete watch")
 
 	fmt.Printf("watch '%v' deleted\n", wName)
@@ -109,10 +122,11 @@ func wList(c *cli.Context) error {
 
 	w := tabwriter.NewWriter(os.Stdout, 0, 0, 1, ' ', 0)
 
-	fmt.Fprintf(w, "%v\t%v\t%v\t%v\t%v\t%v\n", "NAME", "NAMESPACE", "OBJTYPE", "LABELS", "FUNCTION_NAME", "FUNCTION_UID")
+	fmt.Fprintf(w, "%v\t%v\t%v\t%v\t%v\n",
+		"NAME", "NAMESPACE", "OBJTYPE", "LABELS", "FUNCTION_NAME")
 	for _, wa := range ws {
 		fmt.Fprintf(w, "%v\t%v\t%v\t%v\t%v\t%v\n",
-			wa.Metadata.Name, wa.Namespace, wa.ObjType, wa.LabelSelector, wa.Function.Name, wa.Function.Uid)
+			wa.Metadata.Name, wa.Spec.Namespace, wa.Spec.Type, wa.Spec.LabelSelector, wa.Spec.FunctionReference.Name)
 	}
 	w.Flush()