Unarchive zip file after fetcher downloads the package (#301)

Fetcher now uncompresses archive files. 

This is triggered by automatically detecting the file format, although maybe we should make that explicit or at least move the detection into the client.

.gitignore

@@ -1,4 +1,13 @@
+fission-bundle/fission-bundle
+# Pycharm IDE
+.idea
+environments/php7/vendor/
+
+# Common backup files
+*.swp
+*.bak
+*.tmp
 *~
 
-# Pycharm IDE
-.idea
+vendor/
+local/

.travis.yml

@@ -1,20 +1,34 @@
 sudo: required
+
 dist: trusty
 
 language: go
+
 go:
-    - 1.7
-    - tip
+  - 1.8
+
+cache:
+  directories:
+    - $HOME/google-cloud-sdk/
+    - $HOME/k8scli
 
 install:
-   - go get github.com/Masterminds/glide
-   - curl -L https://github.com/coreos/etcd/releases/download/v3.0.15/etcd-v3.0.15-linux-amd64.tar.gz -o /tmp/etcd-v3.0.15-linux-amd64.tar.gz && mkdir -p /tmp/test-etcd && tar xzvf /tmp/etcd-v3.0.15-linux-amd64.tar.gz -C /tmp/test-etcd --strip-components=1
+  - go get github.com/Masterminds/glide
+  - hack/travis-kube-setup.sh
+
+env:
+  - KUBECONFIG=${HOME}/.kube/config PATH=$HOME/k8scli:${PATH}
 
 script:
-   - cd ${TRAVIS_BUILD_DIR}
-   - glide install
-   - ./fission-bundle/build.sh
-   - hack/verify-gofmt.sh
-   - /tmp/test-etcd/etcd &
-   - go test -v -i $(go list ./... | grep -v '/vendor/')
-   - go test -v $(go list ./... | grep -v '/vendor/')
+  - cd ${TRAVIS_BUILD_DIR}
+  - glide install
+  - ./fission-bundle/build.sh
+  - hack/verify-gofmt.sh
+  - hack/runtests.sh
+  - test/build_and_test.sh
+
+notifications:
+  slack:
+    secure: YZ34vsfw1TtftJypg1MyP4+ihONI4gaxeS3FghBQli6+EezjzcxOXyj5VD+x0ucXfDeTaDrFfmVN0SAGObOoZUE+ea9KAoTo50tRLaD9kwOTACiekZalC4uuBguH0D1/A6vlbU8dchsr9mvIhbisG6mTncdPtqGYYHtyBQme6ngmmHbVAQFZcIBHmNuDb/HWhSr8KMEuyB6+mBXLYELHnXnf26cOhdGNaagqCOJTiemX85RGwIuOPxyBhKDFMLyHohDT7FJMH/qijveE6YgOYTQC5nYc2Np1KvC7hQkIu4nuyczyYlrNQl/TWv+SVI8PjIs0PYuCuD3gUqoVEi8d94HbrOPzFEpbwDS9P4qL39DGmco1Q56Vqxe6sRI0vDWPb5gCP1lSgs3PMECVn7Wor/pTvcL+C+U2jLwWJUl0vbyWCL7ngl/3iTssV7qBpUrI7Oclwp8LrQo9fPj0DL4gE9rNanpEWjQ6yPGaysIL1zLHtRghhm52A22NJGp71jkS2KEpLi6ZWFYjMeuXw5eOQFhqFlzyRJOmLYa3B607TLWuyo2L2CxAfMmq0FGfemvrkLZIWtlQKK4y9ImpsURwaGT2XCtThFtHl77wEss913nC+T2dX3O5Bl0UmxFd5S3mVM109I8c4lDosxnAjRfS9MheFlrG0gjSJSBCw57x7f0=
+    on_success: change
+    on_failure: always

CODE_OF_CONDUCT.md

@@ -55,7 +55,7 @@ further defined and clarified by project maintainers.
 ## Enforcement
 
 Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project team at soamvasani@platform9.com. All
+reported by contacting the project team at codeofconduct@platform9.com. All
 complaints will be reviewed and investigated and will result in a response that
 is deemed necessary and appropriate to the circumstances. The project team is
 obligated to maintain confidentiality with regard to the reporter of an incident.

Compiling.md

@@ -0,0 +1,55 @@
+Compiling Fission
+=================
+
+[You only need to do this if you're making Fission changes; if you're
+just deploying Fission, use fission.yaml which points to prebuilt
+images.]
+
+You'll need the `go` compiler and tools installed, along with the
+[glide dependency management
+tool](https://github.com/Masterminds/glide#install).  You'll also need
+docker for building images.
+
+The server side is compiled as one binary ("fission-bundle") which
+contains controller, poolmgr and router; it invokes the right one
+based on command-line arguments.
+
+To build fission-bundle: clone this repo to
+`$GOPATH/src/github.com/fission/fission`, then from the top level
+directory (if you want to build the image with the docker inside
+minikube, you'll need to set the proper environment variables with
+`eval $(minikube docker-env)`):
+
+```
+  # Get dependencies
+  $ glide install
+
+  # Build fission server and an image
+  $ pushd fission-bundle
+  $ ./build.sh
+```
+
+You now need to build the docker image for fission. You can use
+`push.sh` and push it to a docker hub account. But it's easiest to use
+minikube and its built-in docker daemon:
+
+```
+  $ eval $(minikube docker-env)
+  $ docker build -t minikube/fission-bundle .
+```
+
+Next, install fission on your kubernetes cluster:
+
+```
+  # To install, update fission.yaml to point to the image you just made: "minikube/fission-bundle"
+  $ $EDITOR fission.yaml
+  $ kubectl create -f fission.yaml
+  $ kubectl create -f fission-nodeport.yaml
+```
+
+And if you're changing the CLI too, you can build it with:
+
+```
+  # Build Fission CLI
+  $ cd fission && go install
+```

Documentation/Architecture.md

@@ -95,6 +95,19 @@ While a few simple retries are done, there isn't yet a reliable
 message bus between Kubewatcher and the function.  Work for this is
 tracked in issue #64.
 
+Message Queue Trigger
+---------------------
+
+A message queue trigger binds a message queue topic to a function:
+events from that topic cause the function to be invoked with the
+message as the body of the request. The trigger may also contain a
+response topic: if specified, the function's output is sent to this
+response.
+
+Here's a diagram of the components:
+
+![Message queue trigger Diagram](https://user-images.githubusercontent.com/202578/27012344-9457cb24-4f00-11e7-8d6b-926ff01637b3.jpg)
+
 Environment Container
 ---------------------
 
@@ -110,4 +123,22 @@ be loaded with any function.
 When poolmgr needs to create a service for a function, it calls
 fetcher to fetch the function.  Fetcher downloads the function into a
 volume shared between fetcher and this environment container.  Poolmgr
-then requests the container to load the function.
+then requests the container to load the function.
+
+Logger
+------
+
+Logger helps to forward function logs to centralized db service for log
+persistence. Currently only influxdb is supported to store logs.
+Following is a diagram describe how log service works:
+
+![Logger Diagram](https://cloud.githubusercontent.com/assets/202578/23100399/b0e3ea00-f6ba-11e6-8f2f-6588cfef2e84.png)
+
+1. Pool manager choose a pod from pool to execute user function
+2. Pool manager makes a HTTP POST to logger helper, once helper receives 
+the request it creates a symlink to container log for fluentd.
+3. Fluentd reads log from symlink and pipes to influxdb
+4. `fission function logs ...` retrieve event logs from influxdb with 
+optional log filter
+5. Pool manager removes function pod from pool
+6. Pool manager asks logger helper to stop piping logs, logger removes symlink.

Documentation/Roadmap.md

@@ -0,0 +1,106 @@
+# Fission Roadmap
+
+## Function features ([area-func](https://github.com/fission/fission/labels/area-func))
+
+- Secrets, configmaps, env vars
+- Volumes
+- Mem requests and limits
+- Function exec time deadline
+- Expose a regular K8s Service for a function
+
+## Fission API ([area-api](https://github.com/fission/fission/labels/area-api))
+
+- TPR-based controller
+- API authentication
+- Aggregated API server
+
+## Development Workflows ([area-dev](https://github.com/fission/fission/labels/area-dev))
+
+- Function Versioning
+- Versioning for a group of functions
+- Rolling upgrades
+  - for one function
+  - for multiple functions
+  - for functions + other kubernetes deployments
+- Unit testing
+
+## API Gateway / Ingress features ([area-ingress](https://github.com/fission/fission/labels/area-ingress))
+
+- Function authn hooks
+- K8s Ingress flag
+- Bundle an ingress controller?
+
+## Workflows and Function composition ([area-composition](https://github.com/fission/fission/labels/area-composition))
+
+- Simple Composition - Sync
+- Simple Composition - Async
+- Hooks (pre, post, on-error)
+- Workflows
+- Testing in the presence of function composition
+
+## Events ([area-events](https://github.com/fission/fission/labels/area-events))
+
+- NATS
+- Kafka
+- AWS: SNS, SQS
+- Google PubSub
+- RabbitMQ
+- Other event sources
+
+- Bundle an event queue (NATS streaming, most probably)
+
+## Operability ([area-ops](https://github.com/fission/fission/labels/area-ops))
+
+### Fission Install/Upgrade ([area-install](https://github.com/fission/fission/labels/area-install))
+
+- Helm Installer for Fission
+- Helm installation for fission functions
+- CLI installer/upgrader? ("fission upgrade")
+- Upgrade checker/reminder (like minikube does)
+- CLI auto-upgrader
+
+### Function observation ([area-observe](https://github.com/fission/fission/labels/area-observe))
+
+- Function Logging
+- Tracing -- Opentracing
+- Metrics -- Prometheus
+- Function exception tracking
+- Logging function load errors
+- Tracing fission overheads for each function
+
+## Function Security
+
+- Function isolation (is authz hook sufficient or do we need something like mutual TLS?)
+- Function service accounts
+
+## UX, especially for beginners ([area-ux](https://github.com/fission/fission/labels/area-ux))
+
+- Fission CLI should include a tutorial
+- Fission CLI should have a way to drop you into the UI
+- Eliminate FISSION_URL, just use kube client to find fission url.  Also useful to grab credentials.
+
+## Documentation ([area-doc](https://github.com/fission/fission/labels/area-doc))
+
+- Installation guide improvements
+- Troubleshooting guide for common problems
+- FAQ
+- Performance overview
+- Render docs nicely to fission.io
+
+## Web UI (tracked separately in the fission-ui repo)
+
+## Performance and Scalability ([area-perf](https://github.com/fission/fission/labels/area-perf))
+
+- Autoscaling
+- Cold-start optimization -- optimistically choose from pool, save about ~20msec
+- Cold-start optimization -- preload funcs in fetcher
+- Cold-start optimization -- preload libraries in envs (v2) -- mem vs. speed tradeoff
+
+## Function extensibility ([area-ext](https://github.com/fission/fission/labels/area-ext))
+
+- Env v2: easy addition of dependencies etc.
+- Integration with Service Broker
+
+## Multi-area stuff
+
+- Execution strategies: cold-start pool vs create-pod-on-cold-start -- one size doesn't fit all, at least with current tech; abstract over execution strategies according to requirements

Documentation/wip/env-api.md

@@ -0,0 +1,120 @@
+# Environment V2 Fission-Environment API
+
+Fission Environments are the language-specific component of fission.
+
+They must satisfy the interface in this spec.
+
+## Meta
+
+This is version 2.0-alpha of the Fission-Environment API.
+
+(It's unstable and may change without warning until 2.0-beta.)
+
+## Overview
+
+Fission V2 Environments consist of:
+
+ * Metadata
+ * A runtime image
+ * A builder image (optional)
+ * Function Interface Specification
+ * User Documentation
+ * Examples
+
+### Metadata 
+
+See EnvironmentSpec, Runtime, and Builder in types.go.
+
+## Runtime Image
+
+An environment runtime image is a docker container image. It must run
+a server that has two jobs:
+
+(a) Loading a "function" from a file path on demand
+(b) Invoking that function on request
+
+### Function Loading
+
+The environment must expose a single HTTP endpoint (at the port and
+URL specified in the metadata) that loads a function. The function
+load request is a JSON-serialized `FunctionLoadRequest`.
+
+The function load request contains a filepath to load the function
+from. Fission does not define in any way the contents of the path; it
+is completely environment-dependent. It may be a single file, or a
+directory (in case of deployment packages).
+
+The load request may contain an EntryPoint. If it does, the loader
+must interpret this; usually it's the name of a function in a module
+or package containing multiple functions. If there is no entrypoint,
+the environment must use a default; again, the value of thsi default
+is environment-specific.
+
+The load request may contain a URL. If it does, requests to that URL
+should be routed to the function. It defaults to "/".
+
+### Function Invocation
+
+Functions are invoked on HTTP request to the server. The port for the
+request on the runtime container is defined in the Runtime metadata,
+and the URL for the request is specified in the FunctionLoadRequest.
+
+The interface of the function is environment specific; the environment
+must come with a spec for this interface.
+
+## Builder
+
+The builder is a container image that contains tools to build a
+function from source. The source may be a single file or a directory
+of files.
+
+The builder container is invoked with the specified command, with the
+following params:
+
+ 1. File path of the source
+ 2. File path where the output should go
+ 3. Other env or function-specific params passed by the user
+
+The first two parameters are file paths, and all remaining params are
+environment-specific.
+
+The output of the builder should be something that the runtime can
+load and run -- there should be no intermediate steps that need user
+intervention.
+
+### Errors
+
+## Function Interface Spec
+
+The function interface spec is a document that specifies the interface
+of functions and their semantics.  It must specify:
+
+ * How functions are invoked (sync, async)
+ * How the request context is provided to the function (URL, headers, request type, request body)
+ * Function logging
+ * Semantics of function errors and exceptions
+
+
+## Documentation
+
+The docs should contain everything necessary to use the environment:
+
+ * How to add it to a fission cluster
+ * How to write and build functions for this environment (link to the interface spec)
+ * How to modify and rebuild the environment itself
+
+## Examples
+
+Suggested examples to provide:
+
+ * A simple "Hello world"
+ * A function that demonstrates use of the request context: url params,
+   request headers, request body 
+ * A function that does logging
+ * A multi-file function package
+ * A function with dependencies
+ * Functions with shared code
+
+## Compatibility with v1
+
+V1 environment images can be used as v2 environment runtime images. 

Documentation/wip/environments-v2.md

@@ -37,6 +37,11 @@ container.
   annoying to wait until runtime to see a syntax error that could have
   been caught on function upload.
 
+* Starting a Pod without knowing the functions has its limitations: we
+  can't set CPU/memory limits, we can't mount volumes (persistent
+  volumes, secrets, configmaps).  We also can't change the namespace
+  the Pod is in.
+
 * Not great for a large code base
 
 * Some people want to operate at the image level but still get the
@@ -97,71 +102,226 @@ Roughly in order of priority:
 
 ### User stories
 
-#### Compiled language
+#### Environment Creation
 
-User writes a function in Go.
+V1 Environments were just an image.  V2 Environments will be a yaml
+file with the following properties:
+
+* Run time image (required)
+* Version (required)
+* Builder image (optional)
+* Build invocation command (required if builder image specified)
+* File name extension(s) (optional)
+
+The version will be used to distinguish V2 environments from V1.
 
 ```
-      $ fission function create --code blah.go
+$ cat golang.yaml
+type: Environment
+metadata:
+  name: go
+spec:
+  runtimeImage: fission/go-runtime
+  builderImage: fission/go-builder
+  buildCommand:
+  - "/build.sh"
+  fileExtentions:
+  - go
 
-      <compilation errors>
-
-      <user edits file>
-      $ $EDITOR blah.go 
-      <fixes errors>
-
-      $ fission function update --code blah.go
-      <success>
+$ fission env create -f golang.yaml
 ```
 
-(Or perhaps we could have a `fission function check --env x --code y`
-which just does compilation, without creating a function object?
-Useful for integration into IDEs.  Basically, just an on-demand
-builder. Useful when you don't wanna setup anything on your laptop.)
+#### Function creation for compiled languages
+
+User writes a function in a compiled language, for example Go.
+
+```
+$ fission function create --code blah.go
+
+<compilation errors>
+
+<user edits file>
+$ $EDITOR blah.go
+<fixes errors>
+
+$ fission function update --code blah.go
+<success>
+
+$ fission route ... # routes work as usual
+```
 
 This same user story applies to interpreted languages too, where the
 "compilation" step can be used to check for syntax errors.
 
+#### Compiled language, without using fission builds
 
-#### Collections of files
-
-We should probably have a manifest in YAML/JSON/etc syntax for
-specifying a function.  We could also use that YAML to let users
-specify the function's environment, resource requirements, etc.
+User compiles their function locally, resulting in a set of one or
+more binaries. The user packages these up as a zip file, creating a
+"deployment package".
 
 ```
-        $ fission funcion create -f blah.yaml
+$ fission function create --deployment-package foo.zip
 
-        $ cat blah.yaml
-        type: Function
-        metadata:
-           name: ...
-        environment: ...
-        files:
-        - foo.py
-        - bar.py
-        - baz/*.py              
-```     
+$ fission route ... # routes work as usual
+```
 
-The yaml file could specify a list of files.  The fission client would
-deal with packaging up this set of files and uploading the package.
+In this use case, fission is no longer operating at the source
+level. Builds are left to the user and fission only sees the
+deployment package package.
 
+#### Collections of source files
+
+The user can create a source package -- a set of source files in a
+zip.
+
+```
+$ fission function create --source-package foo.zip
+
+```
+
+This workflow works similarly to providing a single source file.
+
+In addition, fission CLI could support automatic creation of source packages, e.g.
+
+```
+$ fission function create --source-files *.js
+```
+
+This is purely client-side "syntactic sugar" -- the CLI creates the
+source package instead of the user having to do it manually.  It
+doesn't change semantics; the source package is still handled as one
+object.
 
 #### Handling Dependencies
 
-A manifest could point at a function's dependency spec.  The
-Environment's "builder" container could then fetch these deps.
+The source package of a function can contain dependency specs.
 
-So a NodeJS function manifest could contain a reference to
-package.json.  A "builder" container in the NodeJS environment would
-then run npm on that function.
+Fission framework proper does not treat this spec in any special way;
+it's just another file in the source package.  These will be
+interpreted by the environment builder.
 
-```     $ cat func.yaml
-        type: Function
-        metadata: ...
-        environment: ...
-        dependencies: package.json
-
-        $ fission function create -f func.yaml
+```
+$ fission function create --source-files *.js --source-files package.json
 ```
 
+In this case, the CLI will create a source package containing the JS
+files and package.json.  The NodeJS environment builder will create a
+deployment package out of these files.  The runtime environment will
+load and run the deployment package.
+
+#### V1 Compatibility
+
+V1 Environments will continue to be supported.  Existing commands will
+continue to work.  V1 environments won't support newer features like
+builds, source and deployment packages, etc.
+
+### Implementation
+
+#### Environment Type
+
+The environment type has a set of new properties: version, runtime
+image, builder image, build command, file extension(s).
+
+#### Function Type
+
+The function type has new properties: source package, deployment
+package.  The literal code string continues to be supported, but it
+will have a specified size limit, say 512KB.
+
+#### Source and Binary Packages
+
+A package is just a zip file.  It's contents are opaque to fission:
+the meaning of its contents is defined by the environment.  Fission's
+job is to manage the storage and delivery of the package into build
+and runtime environments.
+
+#### Storage Service
+
+The storage service will have an HTTP API to upload and download
+files. It can store the packages on a persistent volume or as objects
+in cloud storage services such as S3.
+
+Storage service has a garbage collection API endpoint.  When invoked,
+it will remove all packages that are not referenced from any function.
+
+#### Fetcher
+
+Fetcher gets some new responsibilities:
+
+1. It must now also handle zip/unzip of packages
+
+2. It must know how to upload to the storage service (so it's not
+exactly "fetcher" any more, but...)
+
+#### Runtime Environment Interface
+
+The V2 runtime environment interface is very similar to V1
+environments.  Environments must support a dynamic loader and have an
+HTTP server that forwards requests to the loaded module.
+
+The differences:
+
+* V2 runtimes must support loading a deployment package.  Fetcher is
+  responsible for unzipping a deployment package, but interpretation
+  of the contents is up to the environment's code.  For example, it
+  may have to include the directory where the deployment package is
+  unzipped in its module load path.
+
+[TODO any other differences?]
+
+#### Buildmgr
+
+A new service that will manage builds.  Its design is similar to
+poolmgr, except it is triggered on creation or update of a function,
+rather than HTTP requests.
+
+Buildmgr creates a builder deployment+service for each environment.
+Pods in this deployment run the environment's build container, and
+fetcher, with a shared volume between the two containers.
+
+When a function is created or updated with a source package, buildmgr
+notices this and triggers a build.  First, it calls fetcher to
+download the source package into a shared volume with the build
+container.  It then invokes the builder by running the build
+invocation command in the build container.  Next, it calls fetcher to
+package up the output of the builder and store the built package into
+the the storage service.
+
+Finally, it updates the function object in the controller API with a
+reference to the built package.
+
+[We can collapse this workflow into one request into the builder
+service, which would make it easier to scale up the builder
+deployment; if we used multiple requests we'd need some sort of
+affinity rule, but k8s services only support IP based affinity.]
+
+#### Poolmgr
+
+Poolmgr remains relatively unchanged.  Instead of contructing URLs for
+function metadata, it uses the deployment package URL in the function
+object.
+
+#### CLI
+
+Client libraries and CLI have to deal with the new properties in
+functions and environments.
+
+The CLI will now talk to both storage service and controller.  When a
+function is created, the user can specify the function in one of 3
+ways:
+
+1. One source file, same as v1.
+
+2. A source package (or a set of source files, which is turned into a
+   source package by the CLI)
+
+3. A deployment package
+
+If the file is specified as a source file, fission CLI will use the
+code literal if it's under the size limit; otherwise it should use the
+storage service.  This will allow users to use fission deployments
+with no storage service, but with a size limit on functions.
+
+For the case of a source or deployment package, the CLI first does an
+upload to the storage service, then creates a function object with a
+reference to the uploaded package.

INSTALL.md

@@ -1,12 +1,18 @@
-  * [Running Fission on your Cluster](#running-fission-on-your-cluster)
-     * [Setup Kubernetes](#setup-kubernetes)
-        * [Mac](#install-and-start-kubernetes-on-osx)
-        * [Linux](#or-install-and-start-kubernetes-on-linux)
-     * [Verify access to the cluster](#verify-access-to-the-cluster)
-     * [Get and Run Fission: Minikube or Local cluster](#get-and-run-fission-minikube-or-local-cluster)
-     * [Get and Run Fission: GKE or other Cloud](#get-and-run-fission-gke-or-other-cloud)
-     * [Install the client CLI](#install-the-client-cli)
-     * [Run an example](#run-an-example)
+
+- [Running Fission on your Cluster](#running-fission-on-your-cluster)
+  * [Setup Kubernetes](#setup-kubernetes)
+    + [Install and start Kubernetes on OSX:](#install-and-start-kubernetes-on-osx)
+    + [Or, install and start Kubernetes on Linux:](#or-install-and-start-kubernetes-on-linux)
+  * [Verify access to the cluster](#verify-access-to-the-cluster)
+  * [Get and Run Fission: Minikube or Local cluster](#get-and-run-fission-minikube-or-local-cluster)
+  * [Get and Run Fission: GKE or other Cloud](#get-and-run-fission-gke-or-other-cloud)
+  * [Get and Run Fission: OpenShift](#get-and-run-fission-openshift)
+    + [Using Minishift or Local Cluster](#using-minishift-or-local-cluster)
+    + [Using other clouds](#using-other-clouds)
+  * [Install the client CLI](#install-the-client-cli)
+  * [Run an example](#run-an-example)
+  * [Enable Persistent Function Logs (Optional)](#enable-persistent-function-logs-optional)
+  * [Use the web based Fission-ui (Optional)](#use-the-web-based-fission-ui-optional)
 
 ## Running Fission on your Cluster
 
@@ -17,14 +23,14 @@ You can install Kubernetes on your laptop with [minikube](https://github.com/kub
 #### Install and start Kubernetes on OSX:
 ```bash
   $ curl -LO https://storage.googleapis.com/kubernetes-release/release/$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)/bin/darwin/amd64/kubectl && chmod +x kubectl && sudo mv kubectl /usr/local/bin
-  $ curl -Lo minikube https://storage.googleapis.com/minikube/releases/v0.14.0/minikube-darwin-amd64 && chmod +x minikube && sudo mv minikube /usr/local/bin/
+  $ curl -Lo minikube https://storage.googleapis.com/minikube/releases/v0.16.0/minikube-darwin-amd64 && chmod +x minikube && sudo mv minikube /usr/local/bin/
   $ minikube start
 ```
 
 #### Or, install and start Kubernetes on Linux:
 ```bash
   $ curl -LO https://storage.googleapis.com/kubernetes-release/release/$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)/bin/linux/amd64/kubectl && chmod +x kubectl && sudo mv kubectl /usr/local/bin
-  $ curl -Lo minikube https://storage.googleapis.com/minikube/releases/v0.14.0/minikube-linux-amd64 && chmod +x minikube && sudo mv minikube /usr/local/bin/
+  $ curl -Lo minikube https://storage.googleapis.com/minikube/releases/v0.16.0/minikube-linux-amd64 && chmod +x minikube && sudo mv minikube /usr/local/bin/
   $ minikube start
 ```
 
@@ -43,8 +49,8 @@ set up services with NodePort.  This exposes fission on ports 31313
 and 31314.
 
 ```
-  $ kubectl create -f http://fission.io/fission.yaml
-  $ kubectl create -f http://fission.io/fission-nodeport.yaml
+  $ kubectl create -f https://github.com/fission/fission/releases/download/nightly20170705/fission-rbac.yaml
+  $ kubectl create -f https://github.com/fission/fission/releases/download/nightly20170705/fission-nodeport.yaml
 ```
 
 Set the FISSION_URL and FISSION_ROUTER environment variables.
@@ -66,8 +72,8 @@ If you're using GKE or any other cloud provider that supports the
 LoadBalancer service type, use these commands:
 
 ```
-  $ kubectl create -f http://fission.io/fission.yaml
-  $ kubectl create -f http://fission.io/fission-cloud.yaml
+  $ kubectl create -f https://github.com/fission/fission/releases/download/nightly20170705/fission-rbac.yaml
+  $ kubectl create -f https://github.com/fission/fission/releases/download/nightly20170705/fission-cloud.yaml
 ```
 
 Save the external IP addresses of controller and router services in
@@ -80,20 +86,62 @@ svc```).  Then:
   $ export FISSION_ROUTER=$(kubectl --namespace fission get svc router -o=jsonpath='{..ip}')
 ```
 
+### Get and Run Fission: OpenShift
+
+If you're using OpenShift, it's possible to run Fission on it! The
+deployment template needs to be deployed as a user with cluster-admin
+permissions (like `system:admin`), as it needs to create a
+`ClusterRole` for deploying function containers from the `fission`
+namespace/project.
+
+Identically as with Kubernetes, you need to set the FISSION_URL and FISSION_ROUTER environment variables. If you're using minishift, use these commands:
+
+```
+  $ export FISSION_URL=http://$(minishift ip):31313¬
+  $ export FISSION_ROUTER=$(minishift ip):31314¬
+```
+#### Using Minishift or Local Cluster
+
+If you're using minishift or no cloud provider, use these commands to set up services with NodePort. This exposes fission on ports 31313 and 31314.
+
+```
+  $ oc login -u system:admin
+  $ oc create -f https://github.com/fission/fission/releases/download/nightly20170705/fission-openshift.yaml
+  $ oc create -f https://github.com/fission/fission/releases/download/nightly20170705/fission-nodeport.yaml
+```
+
+#### Using other clouds
+
+If you're using any cloud provider that supports the LoadBalancer service type, use these commands:
+
+```
+$ oc login -u system:admin
+$ oc create -f https://github.com/fission/fission/releases/download/nightly20170705/fission-openshift.yaml
+$ oc create -f https://github.com/fission/fission/releases/download/nightly20170705/fission-cloud.yaml
+```
+After these steps, you should be able to run fission client as with kubernetes.
+
 ### Install the client CLI
 
+#### Mac OS
+
 Get the CLI binary for Mac:
 
 ```
-  $ curl http://fission.io/mac/fission > fission && chmod +x fission && sudo mv fission /usr/local/bin/
+  $ curl -Lo fission https://github.com/fission/fission/releases/download/nightly20170705/fission-cli-osx && chmod +x fission && sudo mv fission /usr/local/bin/
 ```
 
-Or Linux:
+#### Linux
 
 ```
-  $ curl http://fission.io/linux/fission > fission && chmod +x fission && sudo mv fission /usr/local/bin/
+  $ curl -Lo fission https://github.com/fission/fission/releases/download/nightly20170705/fission-cli-linux && chmod +x fission && sudo mv fission /usr/local/bin/
 ```
 
+#### Windows
+
+For Windows, you can use the linux binary on WSL. Or you can download
+this windows executable: [fission.exe](https://github.com/fission/fission/releases/download/nightly20170705/fission-cli-windows.exe)
+
 ### Run an example
 
 Finally, you're ready to use Fission!
@@ -101,7 +149,7 @@ Finally, you're ready to use Fission!
 ```
   $ fission env create --name nodejs --image fission/node-env
 
-  $ echo 'module.exports = function(context, callback) { callback(200, "Hello, world!\n"); }' > hello.js  
+  $ curl https://raw.githubusercontent.com/fission/fission/master/examples/nodejs/hello.js > hello.js
 
   $ fission function create --name hello --env nodejs --code hello.js
   
@@ -110,3 +158,64 @@ Finally, you're ready to use Fission!
   $ curl http://$FISSION_ROUTER/hello
   Hello, world!
 ```
+
+
+### Enable Persistent Function Logs (Optional)
+
+Fission uses InfluxDB to store logs and fluentd to forward them from
+function pods into InfluxDB.  
+
+```
+  $ kubectl create -f https://github.com/fission/fission/releases/download/nightly20170705/fission-logger.yaml
+```
+
+That's it for the basic setup.  You can now use following command to view function logs:
+
+```
+  $ fission function logs --name hello
+```
+
+You can also list the all the pods that have hosted the function
+(including ones that aren't alive any more) and view logs for a
+particular pod:
+
+```
+  $ fission function pods --name hello
+
+  $ fission function logs --name hello --pod <pod name>
+```
+
+### Use the web based Fission-ui (Optional)
+
+[Fission-ui](https://github.com/fission/fission-ui) is the ui for fission maintained by the community.
+It allows users to observe and manage fission. It also provides a simple online development environment for serverless functions.
+
+To setup Fission-ui with fission in k8s is simple:
+
+```bash
+  # Run this after fission is deployed
+  $ kubectl create -f https://raw.githubusercontent.com/fission/fission-ui/master/docker/fission-ui.yaml
+```
+
+Then open `http://node-ip:31319` to use Fission-ui.
+
+For more infomation, please check out [Fission-ui Readme](https://github.com/fission/fission-ui/blob/master/README.md).
+
+### Install NATS for message-queue based triggers (Optional)
+
+Fission supports message queue triggers that allow you to invoke
+functions based on events in a queue.  For now, NATS-Streaming is the
+only supported message queue.
+
+You can install NATS Streaming on your Kubernetes cluster with:
+
+```
+  $ kubectl create -f https://github.com/fission/fission/releases/download/nightly20170705/fission-nats.yaml
+```
+
+You can subscribe to a NATS Streaming queue with a command like this:
+(See `fission mqtrigger --help` for details)
+
+```
+  $ fission mqtrigger create --name myQueueTrigger --function processEvent --topic "myQueue.request" 
+```

README.md

@@ -15,8 +15,8 @@ extend Fission if you want to.
 
 Fission is extensible to any language; the core is written in Go, and
 language-specific parts are isolated in something called
-_environments_ (more below).  Fission currently supports NodeJS and
-Python, with more languages coming soon.
+_environments_ (more below).  Fission currently supports NodeJS, Python, Ruby, Go, 
+PHP, Bash, and any Linux executable, with more languages coming soon.
 
 ### Performance: 100msec cold start
 
@@ -63,7 +63,7 @@ Usage
   $ fission env create --name nodejs --image fission/node-env
 
   # A javascript one-liner that prints "hello world"
-  $ echo 'module.exports = function(context, callback) { callback(200, "Hello, world!\n"); }' > hello.js  
+  $ curl https://raw.githubusercontent.com/fission/fission/master/examples/nodejs/hello.js > hello.js
 
   # Upload your function code to fission
   $ fission function create --name hello --env nodejs --code hello.js
@@ -81,148 +81,12 @@ See the [examples](examples) directory for more.
 Running Fission on your Cluster
 ===============================
 
-### Setup Kubernetes
-
-You can install Kubernetes on your laptop with [minikube](https://github.com/kubernetes/minikube):
-
-#### Install and start Kubernetes on OSX:
-```bash
-  $ curl -LO https://storage.googleapis.com/kubernetes-release/release/$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)/bin/darwin/amd64/kubectl && chmod +x kubectl && sudo mv kubectl /usr/local/bin
-  $ curl -Lo minikube https://storage.googleapis.com/minikube/releases/v0.14.0/minikube-darwin-amd64 && chmod +x minikube && sudo mv minikube /usr/local/bin/
-  $ minikube start
-```
-
-#### Or, install and start Kubernetes on Linux:
-```bash
-  $ curl -LO https://storage.googleapis.com/kubernetes-release/release/$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)/bin/linux/amd64/kubectl && chmod +x kubectl && sudo mv kubectl /usr/local/bin
-  $ curl -Lo minikube https://storage.googleapis.com/minikube/releases/v0.14.0/minikube-linux-amd64 && chmod +x minikube && sudo mv minikube /usr/local/bin/
-  $ minikube start
-```
-
-Or, you can use [Google Container Engine's](https://cloud.google.com/container-engine/) free trial to get a 3 node cluster.
-
-### Verify access to the cluster
-
-```
-  $ kubectl version
-```
-
-### Get and Run Fission: Minikube or Local cluster
-
-If you're using minikube or no cloud provider, use these commands to
-set up services with NodePort.  This exposes fission on ports 31313
-and 31314.
-
-```
-  $ kubectl create -f http://fission.io/fission.yaml
-  $ kubectl create -f http://fission.io/fission-nodeport.yaml
-```
-
-Set the FISSION_URL and FISSION_ROUTER environment variables.
-FISSION_URL is used by the fission CLI to find the server.
-FISSION_URL should be prefixed with a `http://`.  (FISSION_ROUTER is
-only needed for the examples below to work.)
-
-If you're using minikube, use these commands:
-
-```
-  $ export FISSION_URL=http://$(minikube ip):31313
-  $ export FISSION_ROUTER=$(minikube ip):31314
-```
-
-
-### Get and Run Fission: GKE or other Cloud
-
-If you're using GKE or any other cloud provider that supports the
-LoadBalancer service type, use these commands:
-
-```
-  $ kubectl create -f http://fission.io/fission.yaml
-  $ kubectl create -f http://fission.io/fission-cloud.yaml
-```
-
-Save the external IP addresses of controller and router services in
-FISSION_URL and FISSION_ROUTER, respectively.  Wait for services to
-get IP addresses (check this with ```kubectl --namespace fission get
-svc```).  Then:
-
-```
-  $ export FISSION_URL=http://$(kubectl --namespace fission get svc controller -o=jsonpath='{..ip}')
-  $ export FISSION_ROUTER=$(kubectl --namespace fission get svc router -o=jsonpath='{..ip}')
-```
-
-### Install the client CLI
-
-Get the CLI binary for Mac:
-
-```
-  $ curl http://fission.io/mac/fission > fission && chmod +x fission && sudo mv fission /usr/local/bin/
-```
-
-Or Linux:
-
-```
-  $ curl http://fission.io/linux/fission > fission && chmod +x fission && sudo mv fission /usr/local/bin/
-```
-
-### Run an example
-
-Finally, you're ready to use Fission!
-
-```
-  $ fission env create --name nodejs --image fission/node-env
-
-  $ echo 'module.exports = function(context, callback) { callback(200, "Hello, world!\n"); }' > hello.js  
-
-  $ fission function create --name hello --env nodejs --code hello.js
-  
-  $ fission route create --method GET --url /hello --function hello
-  
-  $ curl http://$FISSION_ROUTER/hello
-  Hello, world!
-```
+See the [installation guide](INSTALL.md).
 
 Compiling Fission
 =================
 
-[You only need to do this if you're making Fission changes; if you're
-just deploying Fission, use fission.yaml which points to prebuilt
-images.]
-
-You'll need go installed, along with the glide dependecy management
-tool.  You'll also need docker for building images.
-
-The server side is compiled as one binary ("fission-bundle") which
-contains controller, poolmgr and router; it invokes the right one
-based on command-line arguments.
-
-To build fission-bundle: clone this repo, then from the top level
-directory:
-
-```
-  # Get dependencies
-  $ glide install
-
-  # Build fission server and an image
-  $ pushd fission-bundle
-  $ ./build.sh
-
-  # Edit push.sh to point to your registry
-  $ $EDITOR push.sh
-  $ ./push.sh
-  $ popd
-
-  # To install, update fission.yaml to point to your compiled image
-  $ $EDITOR fission.yaml
-  $ kubectl create -f fission.yaml
-```
-
-If you're changing the CLI:
-
-```
-  # Build Fission CLI
-  $ cd fission && go install
-```
+See the [compilation guide](Compiling.md).
 
 Status
 ======
@@ -230,9 +94,8 @@ Status
 Fission is in early alpha.  It's not suitable for production use just
 yet.  
 
-We're looking for early developer feedback -- if you do use Fission,
-we'd love to hear how it's working for you, what parts in particular
-you'd like to see improved, and so on.  Talk to us on
-[slack](http://slack.fission.io) or
+Reach us on [slack](http://slack.fission.io) or
 [twitter](https://twitter.com/fissionio).
 
+Fission is a project by [Platform9 Systems](https://platform9.com/fission/)
+and [many contributors](https://github.com/fission/fission/graphs/contributors).

builder/builder.go

@@ -0,0 +1,166 @@
+/*
+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 builder
+
+import (
+	"bufio"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/dchest/uniuri"
+)
+
+const (
+	// supported environment variables
+	envSrcPkg    = "SRC_PKG"
+	envDeployPkg = "DEPLOY_PKG"
+)
+
+type (
+	PackageBuildRequest struct {
+		SrcPkgFilename string `json:"srcPkgFilename"`
+		// Command for builder to run with.
+		// A build command consists of commands, parameters and environment variables.
+		// For now, two environment variables are supported:
+		// 1. SRC_PKG: path to source package directory
+		// 2. DEPLOY_PKG: path to deployment package directory
+		BuildCommand string `json:"command"`
+	}
+
+	PackageBuildResponse struct {
+		ArtifactFilename string `json:"artifactFilename"`
+		BuildLogs        string `json:"buildLogs"`
+	}
+
+	Builder struct {
+		sharedVolumePath string
+	}
+)
+
+func MakeBuilder(sharedVolumePath string) *Builder {
+	return &Builder{
+		sharedVolumePath: sharedVolumePath,
+	}
+}
+
+func (builder *Builder) Handler(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		http.Error(w, "", 405)
+		return
+	}
+
+	startTime := time.Now()
+	defer func() {
+		elapsed := time.Now().Sub(startTime)
+		log.Printf("elapsed time in build request = %v", elapsed)
+	}()
+
+	// parse request
+	body, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		log.Printf("Error reading request body")
+		http.Error(w, err.Error(), 500)
+		return
+	}
+	var req PackageBuildRequest
+	err = json.Unmarshal(body, &req)
+	if err != nil {
+		log.Printf("Error parsing json body: %v", err)
+		http.Error(w, err.Error(), 400)
+		return
+	}
+	log.Printf("Builder received request: %v", req)
+
+	log.Println("Starting build...")
+	srcPkgPath := filepath.Join(builder.sharedVolumePath, req.SrcPkgFilename)
+	deployPkgFilename := fmt.Sprintf("%v-%v", req.SrcPkgFilename, strings.ToLower(uniuri.NewLen(6)))
+	deployPkgPath := filepath.Join(builder.sharedVolumePath, deployPkgFilename)
+	buildLogs, err := builder.build(req.BuildCommand, srcPkgPath, deployPkgPath)
+	if err != nil {
+		e := errors.New(fmt.Sprintf("Error building source package: %v", err))
+		http.Error(w, e.Error(), 500)
+		return
+	}
+
+	resp := PackageBuildResponse{
+		ArtifactFilename: deployPkgFilename,
+		BuildLogs:        buildLogs,
+	}
+
+	rBody, err := json.Marshal(resp)
+	if err != nil {
+		e := errors.New(fmt.Sprintf("Error encoding response body: %v", err))
+		http.Error(w, e.Error(), 500)
+		return
+	}
+
+	w.Header().Add("Content-Type", "application/json")
+	w.Write(rBody)
+	w.WriteHeader(http.StatusOK)
+}
+
+func (builder *Builder) build(command string, srcPkgPath string, deployPkgPath string) (string, error) {
+	cmd := exec.Command(command)
+	cmd.Dir = srcPkgPath
+	// set env variables for build command
+	cmd.Env = append(os.Environ(),
+		fmt.Sprintf("%v=%v", envSrcPkg, srcPkgPath),
+		fmt.Sprintf("%v=%v", envDeployPkg, deployPkgPath),
+	)
+
+	cmdReader, err := cmd.StdoutPipe()
+	if err != nil {
+		return "", errors.New(fmt.Sprintf("Error creating stdout pipe for cmd: %v", err.Error()))
+	}
+
+	scanner := bufio.NewScanner(cmdReader)
+
+	err = cmd.Start()
+	if err != nil {
+		return "", errors.New(fmt.Sprintf("Error starting cmd: %v", err.Error()))
+	}
+
+	var buildLogs string
+
+	fmt.Println("\n=== Build Logs ===")
+	for scanner.Scan() {
+		output := scanner.Text()
+		fmt.Println(output)
+		buildLogs += fmt.Sprintf("%v\n", output)
+	}
+	fmt.Println("==================\n")
+
+	if err := scanner.Err(); err != nil {
+		return "", errors.New(fmt.Sprintf("Error reading cmd output: %v", err.Error()))
+	}
+
+	err = cmd.Wait()
+	if err != nil {
+		return "", errors.New(fmt.Sprintf("Error waiting for cmd: %v", err.Error()))
+	}
+
+	return buildLogs, nil
+}

builder/client/client.go

@@ -0,0 +1,56 @@
+/*
+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 client
+
+import (
+	"bytes"
+	"encoding/json"
+	"net/http"
+	"strings"
+
+	"github.com/fission/fission"
+	builder "github.com/fission/fission/builder"
+)
+
+type (
+	Client struct {
+		url string
+	}
+)
+
+func MakeClient(serverUrl string) *Client {
+	return &Client{
+		url: strings.TrimSuffix(serverUrl, "/"),
+	}
+}
+
+func (c *Client) Build(req *builder.PackageBuildRequest) error {
+	body, err := json.Marshal(req)
+	if err != nil {
+		return err
+	}
+	resp, err := http.Post(c.url, "application/json", bytes.NewReader(body))
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		return fission.MakeErrorFromHTTP(resp)
+	}
+	return nil
+}

builder/cmd/Dockerfile

@@ -0,0 +1,5 @@
+FROM alpine:3.4
+
+ADD builder /
+
+EXPOSE 8000

builder/cmd/build.sh

@@ -0,0 +1,2 @@
+#!/bin/sh
+GOOS=linux GOARCH=386 go build -o builder .

builder/cmd/main.go

@@ -0,0 +1,42 @@
+/*
+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 (
+	"log"
+	"net/http"
+	"os"
+
+	builder "github.com/fission/fission/builder"
+)
+
+// Usage: builder <shared volume path>
+func main() {
+	dir := os.Args[1]
+	if _, err := os.Stat(dir); err != nil {
+		if os.IsNotExist(err) {
+			err = os.MkdirAll(dir, os.ModeDir|0700)
+			if err != nil {
+				log.Fatalf("Error creating directory: %v", err)
+			}
+		}
+	}
+	builder := builder.MakeBuilder(dir)
+	mux := http.NewServeMux()
+	mux.HandleFunc("/", builder.Handler)
+	http.ListenAndServe(":8000", mux)
+}

cache/cache.go

@@ -17,10 +17,10 @@ limitations under the License.
 package cache
 
 import (
-	"time"
-
 	"errors"
 	"fmt"
+	"time"
+
 	"github.com/fission/fission"
 )
 

cache/cache_test.go

@@ -16,9 +16,11 @@ limitations under the License.
 
 package cache
 
-import "testing"
-import "log"
-import "time"
+import (
+	"log"
+	"testing"
+	"time"
+)
 
 func checkErr(err error) {
 	if err != nil {

charts/README.md

@@ -0,0 +1,82 @@
+# Fission
+
+[Fission](http://fission.io/) is a framework for serverless functions on Kubernetes.
+
+
+## Prerequisites
+
+- Kubernetes 1.6+ with Beta APIs enabled
+
+
+## Helm charts
+
+The following table lists two helm charts for Fission.
+
+| Parameter      | Description                                                                            |
+| ---------------| ---------------------------------------------------------------------------------------|
+| `fission-core` | FaaS essentials, and triggers for HTTP, Timers and Kubernetes Watches                  |
+| `fission-all`  | Log aggregation with fluentd and InfluxDB; NATS for message queue triggers; Fission-UI |
+
+## Installing the chart
+
+To install the chart with the release name `my-release`,
+
+```bash
+$ helm install --name my-release fission-all
+```
+
+## Uninstalling the chart
+
+To uninstall/delete chart,
+
+```bash
+$ helm delete my-release
+```
+
+## Configuration
+
+The following table lists the configurable parameters of the Fission chart and their default values.
+
+| Parameter           | Description                                | Default                  |
+| ------------------- | ------------------------------------------ | ------------------------ |
+| `serviceType`       | Type of service to use                     | `LoadBalancer`.          |
+| `image`             | Fission image                              | `fission/fission-bundle` |
+| `imageTag`          | Fission image tag                          | `alpha20170124`          |
+| `fetcherImage`      | Fission fetcher image                      | `fission/fetcher`        |
+| `fetcherImageTag`   | Fission fetcher image tag                  | `latest`                 |
+| `controllerPort`    | Fission Controller Service Port            | `31313`                  |
+| `routerPort`        | Fission Router Service Port                | `31314`                  |
+| `functionNamespace` | Namespace for Fission functions            | `fission-function`       |
+| `openshift`         | RBAC for openshift                         | `false`                  |
+
+
+* Extra configuration for `fission-all`
+
+| Parameter              | Description                 | Default                    |
+| ---------------------- | --------------------------- | -------------------------- |
+| `logger.influxdbAdmin` | Log database admin username | `admin`.                   |
+| `logger.fluentdImage`  | Logger fluentd image        | `fission/fluentd`          |
+| `fissionUiImage`       | Fission ui image            | `fission/fission-ui:0.1.0` |
+| `nats.authToken`       | Nats streaming auth token   | `defaultFissionAuthToken`  |
+| `nats.clusterID`       | Nats streaming clusterID    | `fissionMQTrigger`         |
+
+
+
+Specify each parameter using the `--set key=value[,key=value]` argument to `helm install`. For example,
+
+```bash
+$ helm install --name my-release --set image=custom/fission-bundle,imageTag=v1 fission-all
+```
+
+If you're using minikube, set serviceType to NodePort:
+
+```bash
+$ helm install --name my-release --set serviceType=NodePort fission-all
+```
+
+You can also set parameters with a yaml file (see values.yaml for
+what it should look like):
+
+```bash
+$ helm install --name my-release -f values.yaml fission-all
+```

charts/fission-all/.helmignore

@@ -0,0 +1,21 @@
+# Patterns to ignore when building packages.
+# This supports shell glob matching, relative path matching, and
+# negation (prefixed with !). Only one pattern per line.
+.DS_Store
+# Common VCS dirs
+.git/
+.gitignore
+.bzr/
+.bzrignore
+.hg/
+.hgignore
+.svn/
+# Common backup files
+*.swp
+*.bak
+*.tmp
+*~
+# Various IDEs
+.project
+.idea/
+*.tmproj

charts/fission-all/Chart.yaml

@@ -0,0 +1,16 @@
+apiVersion: v1
+name: fission-all
+version: v0.2.0-20170822
+description: Fission is a fast serverless framework for Kubernetes.
+keywords:
+- fission
+- serverless
+home: http://fission.io/
+maintainers:
+  - name: Sanket Sudake
+    email: sanketsudake@gmail.com
+  - name: Soam Vasani
+    email: soamvasani@platform9.com
+  - name: Ta Ching Chen
+    email: contact@tachingchen.com
+engine: gotpl

charts/fission-all/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

charts/fission-all/templates/NOTES.txt

@@ -0,0 +1,40 @@
+1. Install the client CLI.
+
+Mac:
+  $ curl -Lo fission https://github.com/fission/fission/releases/download/nightly20170705/fission-cli-osx && chmod +x fission && sudo mv fission /usr/local/bin/
+
+Linux:
+  $ curl -Lo fission https://github.com/fission/fission/releases/download/nightly20170705/fission-cli-linux && chmod +x fission && sudo mv fission /usr/local/bin/
+
+Windows:
+  For Windows, you can use the linux binary on WSL. Or you can download this windows executable: https://github.com/fission/fission/releases/download/nightly20170705/fission-cli-windows.exe
+
+2. Set the FISSION_URL and FISSION_ROUTER environment variables.
+FISSION_URL is used by the fission CLI to find the server.
+FISSION_URL should be prefixed with a http://. (FISSION_ROUTER is only needed for the examples below to work.)
+
+{{- if contains "NodePort" .Values.serviceType }}
+  $ export FISSION_URL=http://$(minikube ip):{{ .Values.controllerPort }}
+  $ export FISSION_ROUTER=$(minikube ip):{{ .Values.routerPort }}
+
+{{- else if contains "LoadBalancer" .Values.serviceType }}
+  NOTE: It may take a few minutes for the LoadBalancer IP to be available.
+        You can watch the status of by running 'kubectl --namespace fission get -w svc' and 'kubectl --namespace fission get svc -w router'
+
+  $ export FISSION_URL=http://$(kubectl --namespace fission get svc controller -o=jsonpath='{..ip}')
+  $ export FISSION_ROUTER=$(kubectl --namespace fission get svc router -o=jsonpath='{..ip}')
+
+{{- end }}
+
+3. Finally, you're ready to use Fission!
+
+  $ fission env create --name nodejs --image fission/node-env
+
+  $ curl https://raw.githubusercontent.com/fission/fission/master/examples/nodejs/hello.js > hello.js
+
+  $ fission function create --name hello --env nodejs --code hello.js
+
+  $ fission route create --method GET --url /hello --function hello
+
+  $ curl http://$FISSION_ROUTER/hello
+  Hello, world!

charts/fission-all/templates/_helpers.tpl

@@ -0,0 +1,16 @@
+{{/* vim: set filetype=mustache: */}}
+{{/*
+Expand the name of the chart.
+*/}}
+{{- define "name" -}}
+{{- default .Chart.Name .Values.nameOverride | trunc 24 | trimSuffix "-" -}}
+{{- end -}}
+
+{{/*
+Create a default fully qualified app name.
+We truncate at 24 chars because some Kubernetes name fields are limited to this (by the DNS naming spec).
+*/}}
+{{- define "fullname" -}}
+{{- $name := default .Chart.Name .Values.nameOverride -}}
+{{- printf "%s-%s" .Release.Name $name | trunc 24 | trimSuffix "-" -}}
+{{- end -}}

charts/fission-all/templates/deployment.yaml

@@ -0,0 +1,486 @@
+{{ if .Values.openshift }}
+
+# For openshift
+
+---
+apiVersion: v1
+kind: ProjectRequest
+metadata:
+  name: fission
+  labels:
+    name: fission
+
+---
+apiVersion: v1
+kind: ProjectRequest
+metadata:
+  name: {{ .Values.functionNamespace }}
+  labels:
+    name: fission-function
+
+---
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+  name: fission-admin
+  namespace: {{ .Release.Namespace }}
+
+---
+apiVersion: v1
+kind: ClusterRole
+metadata:
+  name: fission:fission-admin
+rules:
+- apiGroups:
+  - extensions
+  attributeRestrictions: null
+  resources:
+  - deployments
+  verbs:
+  - create
+  - get
+  - list
+  - update
+  - watch
+- apiGroups:
+  - ""
+  attributeRestrictions: null
+  resources:
+  - pods
+  verbs:
+  - get
+  - list
+  - update
+
+---
+apiVersion: v1
+groupNames: null
+kind: RoleBinding
+metadata:
+  name: fission:fission-admin
+  namespace: {{ .Values.functionNamespace }}
+roleRef:
+  name: fission:fission-admin
+subjects:
+- kind: ServiceAccount
+  name: fission-admin
+  namespace: {{ .Release.Namespace }}
+userNames:
+- system:serviceaccount:fission:fission-admin
+
+{{ else }}
+
+# For all environments except openshift
+
+---
+apiVersion: v1
+kind: Namespace
+metadata:
+  name: {{ .Values.functionNamespace }}
+  labels:
+    name: fission-function
+    chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
+
+---
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+  name: fission-svc
+  namespace: {{ .Release.Namespace }}
+
+---
+kind: RoleBinding
+apiVersion: rbac.authorization.k8s.io/v1beta1
+metadata:
+  name: fission-admin
+  namespace: {{ .Release.Namespace }}
+subjects:
+  - kind: ServiceAccount
+    name: fission-svc
+    namespace: {{ .Release.Namespace }}
+roleRef:
+  kind: ClusterRole
+  name: admin
+  apiGroup: rbac.authorization.k8s.io
+
+---
+kind: RoleBinding
+apiVersion: rbac.authorization.k8s.io/v1beta1
+metadata:
+  name: fission-function-admin
+  namespace: {{ .Values.functionNamespace }}
+subjects:
+  - kind: ServiceAccount
+    name: fission-svc
+    namespace: {{ .Release.Namespace }}
+roleRef:
+  kind: ClusterRole
+  name: admin
+  apiGroup: rbac.authorization.k8s.io
+
+---
+kind: ClusterRoleBinding
+apiVersion: rbac.authorization.k8s.io/v1beta1
+metadata:
+  name: fission-tpr
+subjects:
+- kind: ServiceAccount
+  name: fission-svc
+  namespace: {{ .Release.Namespace }}
+roleRef:
+  kind: ClusterRole
+  name: cluster-admin
+  apiGroup: rbac.authorization.k8s.io
+
+---
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+  name: fission-fetcher
+  namespace: {{ .Values.functionNamespace }}
+
+---
+kind: ClusterRoleBinding
+apiVersion: rbac.authorization.k8s.io/v1beta1
+metadata:
+  name: fission-fetcher-tpr
+subjects:
+- kind: ServiceAccount
+  name: fission-fetcher
+  namespace: {{ .Values.functionNamespace }}
+roleRef:
+  kind: ClusterRole
+  name: cluster-admin
+  apiGroup: rbac.authorization.k8s.io
+
+{{ end }}
+
+---
+apiVersion: extensions/v1beta1
+kind: Deployment
+metadata:
+  name: controller
+  labels:
+    chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
+spec:
+  replicas: 1
+  template:
+    metadata:
+      labels:
+        svc: controller
+    spec:
+      containers:
+      - name: controller
+        image: "{{ .Values.image }}:{{ .Values.imageTag }}"
+        imagePullPolicy: {{ .Values.pullPolicy }}
+        command: ["/fission-bundle"]
+        args: ["--controllerPort", "8888"]
+      serviceAccount: fission-svc
+
+---
+apiVersion: extensions/v1beta1
+kind: Deployment
+metadata:
+  name: router
+  labels:
+    chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
+spec:
+  replicas: 1
+  template:
+    metadata:
+      labels:
+        svc: router
+    spec:
+      containers:
+      - name: router
+        image: "{{ .Values.image }}:{{ .Values.imageTag }}"
+        imagePullPolicy: {{ .Values.pullPolicy }}
+        command: ["/fission-bundle"]
+        args: ["--routerPort", "8888", "--poolmgrUrl", "http://poolmgr.{{ .Release.Namespace }}"]
+      serviceAccount: fission-svc
+
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: poolmgr
+  labels:
+    svc: poolmgr
+    chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
+spec:
+  type: ClusterIP
+  ports:
+  - port: 80
+    targetPort: 8888
+  selector:
+    svc: poolmgr
+
+---
+apiVersion: extensions/v1beta1
+kind: Deployment
+metadata:
+  name: poolmgr
+  labels:
+    chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
+spec:
+  replicas: 1
+  template:
+    metadata:
+      labels:
+        svc: poolmgr
+    spec:
+      containers:
+      - name: poolmgr
+        image: "{{ .Values.image }}:{{ .Values.imageTag }}"
+        imagePullPolicy: {{ .Values.pullPolicy }}
+        command: ["/fission-bundle"]
+        args: ["--poolmgrPort", "8888", "--namespace", "{{ .Values.functionNamespace }}", "--fission-namespace", "{{ .Release.Namespace }}"]
+        env:
+        - name: FETCHER_IMAGE
+          value: "{{ .Values.fetcherImage }}:{{ .Values.fetcherImageTag }}"
+        - name: FETCHER_IMAGE_PULL_POLICY
+          value: "{{ .Values.pullPolicy }}"
+      serviceAccount: fission-svc
+
+---
+apiVersion: extensions/v1beta1
+kind: Deployment
+metadata:
+  name: kubewatcher
+  labels:
+    chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
+spec:
+  replicas: 1
+  template:
+    metadata:
+      labels:
+        svc: kubewatcher
+    spec:
+      containers:
+      - name: kubewatcher
+        image: "{{ .Values.image }}:{{ .Values.imageTag }}"
+        imagePullPolicy: {{ .Values.pullPolicy }}
+        command: ["/fission-bundle"]
+        args: ["--kubewatcher"]
+      serviceAccount: fission-svc
+
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: influxdb
+  labels:
+    svc: influxdb
+    chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
+spec:
+  type: ClusterIP
+  ports:
+  - port: 8086
+    targetPort: 8086
+  selector:
+    svc: influxdb
+
+---
+apiVersion: extensions/v1beta1
+kind: Deployment
+metadata:
+  name: influxdb
+  labels:
+    chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
+spec:
+  replicas: 1
+  template:
+    metadata:
+      labels:
+        svc: influxdb
+    spec:
+      containers:
+      - name: influxdb
+        image: tutum/influxdb
+        env:
+          - name: PRE_CREATE_DB
+            value: fissionFunctionLog
+          - name: ADMIN_USER
+            valueFrom:
+              secretKeyRef:
+                name: influxdb
+                key: username
+          - name: INFLUXDB_INIT_PWD
+            valueFrom:
+              secretKeyRef:
+                name: influxdb
+                key: password
+
+---
+apiVersion: extensions/v1beta1
+kind: DaemonSet
+metadata:
+  name: logger
+  labels:
+    chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
+spec:
+  template:
+    metadata:
+      labels:
+        svc: logger
+    spec:
+      containers:
+        - name: logger
+          image: "{{ .Values.image }}:{{ .Values.imageTag }}"
+          imagePullPolicy: {{ .Values.pullPolicy }}
+          command: ["/fission-bundle"]
+          args: ["--logger"]
+          volumeMounts:
+            - name: container-log
+              mountPath: /var/log/containers
+              readOnly: true
+            - name: docker-log
+              mountPath: /var/lib/docker/containers
+              readOnly: true
+            - name: fission-log
+              mountPath: /var/log/fission
+              readOnly: false
+          ports:
+            - containerPort: 1234
+              hostPort: 1234
+              protocol: TCP
+        - name: fluentd
+          image: {{ .Values.logger.fluentdImage }}
+          imagePullPolicy: {{ .Values.pullPolicy }}
+          env:
+            - name: INFLUXDB_ADDRESS
+              value: influxdb
+            - name: INFLUXDB_PORT
+              value: "8086"
+            - name: INFLUXDB_DBNAME
+              value: "fissionFunctionLog"
+            - name: INFLUXDB_USERNAME
+              valueFrom:
+                secretKeyRef:
+                  name: influxdb
+                  key: username
+            - name: INFLUXDB_PASSWD
+              valueFrom:
+                secretKeyRef:
+                  name: influxdb
+                  key: password
+          volumeMounts:
+            - name: container-log
+              mountPath: /var/log/containers
+              readOnly: true
+            - name: docker-log
+              mountPath: /var/lib/docker/containers
+              readOnly: true
+            - name: fission-log
+              mountPath: /var/log/fission
+              readOnly: false
+      serviceAccount: fission-svc
+      volumes:
+        - name: container-log
+          hostPath:
+              path: /var/log/containers
+        - name: docker-log
+          hostPath:
+              path: /var/lib/docker/containers
+        - name: fission-log
+          hostPath:
+              path: /var/log/fission
+
+---
+apiVersion: extensions/v1beta1
+kind: Deployment
+metadata:
+  name: timer
+  labels:
+    chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
+spec:
+  replicas: 1
+  template:
+    metadata:
+      labels:
+        svc: timer
+    spec:
+      containers:
+      - name: timer
+        image: "{{ .Values.image }}:{{ .Values.imageTag }}"
+        imagePullPolicy: {{ .Values.pullPolicy }}
+        command: ["/fission-bundle"]
+        args: ["--timer"]
+      serviceAccount: fission-svc
+
+#
+# This is commented out until fission-ui allows configuring the
+# namespace. Right now it just crashes if Release.Namespace !=
+# "fission".
+#
+#---
+#apiVersion: extensions/v1beta1
+#kind: Deployment
+#metadata:
+#  name: fission-ui
+#  labels:
+#    chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
+#spec:
+#  replicas: 1
+#  template:
+#    metadata:
+#      labels:
+#        svc: fission-ui
+#    spec:
+#      containers:
+#      - name: nginx
+#        image: {{ .Values.fissionUiImage }}
+#      - name: kubectl-proxy
+#        image: lachlanevenson/k8s-kubectl
+#        args: ["proxy", "--port", "8001", "--address", "127.0.0.1"]
+#      serviceAccount: fission-svc
+
+---
+apiVersion: extensions/v1beta1
+kind: Deployment
+metadata:
+  labels:
+    svc: nats-streaming
+  name: nats-streaming
+spec:
+  replicas: 1
+  template:
+    metadata:
+      labels:
+        svc: nats-streaming
+    spec:
+      containers:
+      - name: nats-streaming
+        image: nats-streaming
+        args: ["--cluster_id", "{{ .Values.nats.clusterID }}", "--auth", "{{ .Values.nats.authToken }}"]
+        ports:
+        - containerPort: 4222
+          hostPort: 4222
+          protocol: TCP
+
+---
+apiVersion: extensions/v1beta1
+kind: Deployment
+metadata:
+  name: mqtrigger
+  labels:
+    chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
+spec:
+  replicas: 1
+  template:
+    metadata:
+      labels:
+        svc: mqtrigger
+    spec:
+      containers:
+      - name: mqtrigger
+        image: "{{ .Values.image }}:{{ .Values.imageTag }}"
+        imagePullPolicy: {{ .Values.pullPolicy }}
+        command: ["/fission-bundle"]
+        args: ["--mqt"]
+        env:
+        - name: MESSAGE_QUEUE_TYPE
+          value: nats-streaming
+        - name: MESSAGE_QUEUE_URL
+          value: nats://{{ .Values.nats.authToken }}@nats-streaming:4222
+      serviceAccount: fission-svc

charts/fission-all/templates/secrets.yaml

@@ -0,0 +1,10 @@
+apiVersion: v1
+kind: Secret
+metadata:
+  name: influxdb
+  labels:
+    chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
+type: Opaque
+data:
+  username: {{ .Values.logger.influxdbAdmin | b64enc | quote }}
+  password: {{ randAlphaNum 20 | b64enc | quote }}

charts/fission-all/templates/svc.yaml

@@ -0,0 +1,67 @@
+apiVersion: v1
+kind: Service
+metadata:
+  name: router
+  labels:
+    svc: router
+    chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
+spec:
+  type: {{ .Values.serviceType }}
+  ports:
+  - port: 80
+    targetPort: 8888
+    nodePort: {{ .Values.routerPort }}
+  selector:
+    svc: router
+
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: controller
+  labels:
+    svc: controller
+    chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
+spec:
+  type: {{ .Values.serviceType }}
+  ports:
+  - port: 80
+    targetPort: 8888
+    nodePort: {{ .Values.controllerPort }}
+  selector:
+    svc: controller
+
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: fission-ui
+  labels:
+    svc: fission-ui
+    chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
+spec:
+  type: {{ .Values.serviceType }}
+  ports:
+  - port: 80
+    targetPort: 80
+    nodePort: 31319
+  selector:
+    svc: fission-ui
+
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: nats-streaming
+  labels:
+    svc: nats-streaming
+    chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
+spec:
+  type: {{ .Values.serviceType }}
+  ports:
+  - port: 4222
+    targetPort: 4222
+    nodePort: 31316
+  selector:
+    svc: nats-streaming
+

charts/fission-all/values.yaml

@@ -0,0 +1,50 @@
+#
+# Fission chart configuration
+# 
+
+## Kubernetes configuration
+## For minikube, set this to NodePort, elsewhere use LoadBalancer.
+serviceType: LoadBalancer
+
+## Fission image repository
+image: fission/fission-bundle
+
+## Image pull policy
+pullPolicy: IfNotPresent
+
+## Fission image version
+imageTag: v0.2.0-20170822
+
+## Fission fetcher repository
+fetcherImage: fission/fetcher
+
+## Fission fetcher image version
+fetcherImageTag: v0.2.0-20170822
+
+## Port at which Fission controller service should be exposed
+controllerPort: 31313
+
+## Port at which Fission router service should be exposed
+routerPort: 31314
+
+## Namespace in which to run fission functions (this is different from
+## the release namespace)
+functionNamespace: fission-function
+
+## Set up openshift RBAC rule
+openshift: false
+
+## Logger config
+logger:
+  influxdbAdmin: "admin"
+  fluentdImage: fission/fluentd
+
+## Fission ui config
+fissionUiImage: fission/fission-ui:0.1.0
+
+## Message queue trigger config
+### NATS Streaming
+nats:
+  authToken: "defaultFissionAuthToken"
+  clusterID: "fissionMQTrigger"
+  

charts/fission-core/.helmignore

@@ -0,0 +1,21 @@
+# Patterns to ignore when building packages.
+# This supports shell glob matching, relative path matching, and
+# negation (prefixed with !). Only one pattern per line.
+.DS_Store
+# Common VCS dirs
+.git/
+.gitignore
+.bzr/
+.bzrignore
+.hg/
+.hgignore
+.svn/
+# Common backup files
+*.swp
+*.bak
+*.tmp
+*~
+# Various IDEs
+.project
+.idea/
+*.tmproj

charts/fission-core/Chart.yaml

@@ -0,0 +1,16 @@
+apiVersion: v1
+name: fission-core
+version: v0.2.0-20170822
+description: Fission is a fast serverless framework for Kubernetes.
+keywords:
+- fission
+- serverless
+home: http://fission.io/
+maintainers:
+  - name: Sanket Sudake
+    email: sanketsudake@gmail.com
+  - name: Soam Vasani
+    email: soamvasani@platform9.com
+  - name: Ta Ching Chen
+    email: contact@tachingchen.com
+engine: gotpl

charts/fission-core/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

charts/fission-core/templates/NOTES.txt

@@ -0,0 +1,40 @@
+1. Install the client CLI.
+
+Mac:
+  $ curl -Lo fission https://github.com/fission/fission/releases/download/nightly20170705/fission-cli-osx && chmod +x fission && sudo mv fission /usr/local/bin/
+
+Linux:
+  $ curl -Lo fission https://github.com/fission/fission/releases/download/nightly20170705/fission-cli-linux && chmod +x fission && sudo mv fission /usr/local/bin/
+
+Windows:
+  For Windows, you can use the linux binary on WSL. Or you can download this windows executable: https://github.com/fission/fission/releases/download/nightly20170705/fission-cli-windows.exe
+
+2. Set the FISSION_URL and FISSION_ROUTER environment variables.
+FISSION_URL is used by the fission CLI to find the server.
+FISSION_URL should be prefixed with a http://. (FISSION_ROUTER is only needed for the examples below to work.)
+
+{{- if contains "NodePort" .Values.serviceType }}
+  $ export FISSION_URL=http://$(minikube ip):{{ .Values.controllerPort }}
+  $ export FISSION_ROUTER=$(minikube ip):{{ .Values.routerPort }}
+
+{{- else if contains "LoadBalancer" .Values.serviceType }}
+  NOTE: It may take a few minutes for the LoadBalancer IP to be available.
+        You can watch the status of by running 'kubectl --namespace fission get -w svc' and 'kubectl --namespace fission get svc -w router'
+
+  $ export FISSION_URL=http://$(kubectl --namespace fission get svc controller -o=jsonpath='{..ip}')
+  $ export FISSION_ROUTER=$(kubectl --namespace fission get svc router -o=jsonpath='{..ip}')
+
+{{- end }}
+
+3. Finally, you're ready to use Fission!
+
+  $ fission env create --name nodejs --image fission/node-env
+
+  $ curl https://raw.githubusercontent.com/fission/fission/master/examples/nodejs/hello.js > hello.js
+
+  $ fission function create --name hello --env nodejs --code hello.js
+
+  $ fission route create --method GET --url /hello --function hello
+
+  $ curl http://$FISSION_ROUTER/hello
+  Hello, world!

charts/fission-core/templates/_helpers.tpl

@@ -0,0 +1,16 @@
+{{/* vim: set filetype=mustache: */}}
+{{/*
+Expand the name of the chart.
+*/}}
+{{- define "name" -}}
+{{- default .Chart.Name .Values.nameOverride | trunc 24 | trimSuffix "-" -}}
+{{- end -}}
+
+{{/*
+Create a default fully qualified app name.
+We truncate at 24 chars because some Kubernetes name fields are limited to this (by the DNS naming spec).
+*/}}
+{{- define "fullname" -}}
+{{- $name := default .Chart.Name .Values.nameOverride -}}
+{{- printf "%s-%s" .Release.Name $name | trunc 24 | trimSuffix "-" -}}
+{{- end -}}

charts/fission-core/templates/deployment.yaml

@@ -0,0 +1,287 @@
+{{ if .Values.openshift }}
+
+# For openshift
+
+---
+apiVersion: v1
+kind: ProjectRequest
+metadata:
+  name: fission
+  labels:
+    name: fission
+
+---
+apiVersion: v1
+kind: ProjectRequest
+metadata:
+  name: {{ .Values.functionNamespace }}
+  labels:
+    name: fission-function
+
+---
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+  name: fission-admin
+  namespace: {{ .Release.Namespace }}
+
+---
+apiVersion: v1
+kind: ClusterRole
+metadata:
+  name: fission:fission-admin
+rules:
+- apiGroups:
+  - extensions
+  attributeRestrictions: null
+  resources:
+  - deployments
+  verbs:
+  - create
+  - get
+  - list
+  - update
+  - watch
+- apiGroups:
+  - ""
+  attributeRestrictions: null
+  resources:
+  - pods
+  verbs:
+  - get
+  - list
+  - update
+
+---
+apiVersion: v1
+groupNames: null
+kind: RoleBinding
+metadata:
+  name: fission:fission-admin
+  namespace: {{ .Values.functionNamespace }}
+roleRef:
+  name: fission:fission-admin
+subjects:
+- kind: ServiceAccount
+  name: fission-admin
+  namespace: {{ .Release.Namespace }}
+userNames:
+- system:serviceaccount:fission:fission-admin
+
+{{ else }}
+
+# For all environments except openshift
+
+---
+apiVersion: v1
+kind: Namespace
+metadata:
+  name: {{ .Values.functionNamespace }}
+  labels:
+    name: fission-function
+    chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
+
+---
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+  name: fission-svc
+  namespace: {{ .Release.Namespace }}
+
+---
+kind: RoleBinding
+apiVersion: rbac.authorization.k8s.io/v1beta1
+metadata:
+  name: fission-admin
+  namespace: {{ .Release.Namespace }}
+subjects:
+  - kind: ServiceAccount
+    name: fission-svc
+    namespace: {{ .Release.Namespace }}
+roleRef:
+  kind: ClusterRole
+  name: admin
+  apiGroup: rbac.authorization.k8s.io
+
+---
+kind: RoleBinding
+apiVersion: rbac.authorization.k8s.io/v1beta1
+metadata:
+  name: fission-function-admin
+  namespace: {{ .Values.functionNamespace }}
+subjects:
+  - kind: ServiceAccount
+    name: fission-svc
+    namespace: {{ .Release.Namespace }}
+roleRef:
+  kind: ClusterRole
+  name: admin
+  apiGroup: rbac.authorization.k8s.io
+
+---
+kind: ClusterRoleBinding
+apiVersion: rbac.authorization.k8s.io/v1beta1
+metadata:
+  name: fission-tpr
+subjects:
+- kind: ServiceAccount
+  name: fission-svc
+  namespace: {{ .Release.Namespace }}
+roleRef:
+  kind: ClusterRole
+  name: cluster-admin
+  apiGroup: rbac.authorization.k8s.io
+
+---
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+  name: fission-fetcher
+  namespace: {{ .Values.functionNamespace }}
+
+---
+kind: ClusterRoleBinding
+apiVersion: rbac.authorization.k8s.io/v1beta1
+metadata:
+  name: fission-fetcher-tpr
+subjects:
+- kind: ServiceAccount
+  name: fission-fetcher
+  namespace: {{ .Values.functionNamespace }}
+roleRef:
+  kind: ClusterRole
+  name: cluster-admin
+  apiGroup: rbac.authorization.k8s.io
+
+{{ end }}
+
+---
+apiVersion: extensions/v1beta1
+kind: Deployment
+metadata:
+  name: controller
+  labels:
+    chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
+spec:
+  replicas: 1
+  template:
+    metadata:
+      labels:
+        svc: controller
+    spec:
+      containers:
+      - name: controller
+        image: "{{ .Values.image }}:{{ .Values.imageTag }}"
+        imagePullPolicy: {{ .Values.pullPolicy }}
+        command: ["/fission-bundle"]
+        args: ["--controllerPort", "8888"]
+      serviceAccount: fission-svc
+
+---
+apiVersion: extensions/v1beta1
+kind: Deployment
+metadata:
+  name: router
+  labels:
+    chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
+spec:
+  replicas: 1
+  template:
+    metadata:
+      labels:
+        svc: router
+    spec:
+      containers:
+      - name: router
+        image: "{{ .Values.image }}:{{ .Values.imageTag }}"
+        imagePullPolicy: {{ .Values.pullPolicy }}
+        command: ["/fission-bundle"]
+        args: ["--routerPort", "8888", "--poolmgrUrl", "http://poolmgr.{{ .Release.Namespace }}"]
+      serviceAccount: fission-svc
+
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: poolmgr
+  labels:
+    svc: poolmgr
+    chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
+spec:
+  type: ClusterIP
+  ports:
+  - port: 80
+    targetPort: 8888
+  selector:
+    svc: poolmgr
+
+---
+apiVersion: extensions/v1beta1
+kind: Deployment
+metadata:
+  name: poolmgr
+  labels:
+    chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
+spec:
+  replicas: 1
+  template:
+    metadata:
+      labels:
+        svc: poolmgr
+    spec:
+      containers:
+      - name: poolmgr
+        image: "{{ .Values.image }}:{{ .Values.imageTag }}"
+        imagePullPolicy: {{ .Values.pullPolicy }}
+        command: ["/fission-bundle"]
+        args: ["--poolmgrPort", "8888", "--namespace", "{{ .Values.functionNamespace }}", "--fission-namespace", "{{ .Release.Namespace }}"]
+        env:
+        - name: FETCHER_IMAGE
+          value: "{{ .Values.fetcherImage }}:{{ .Values.fetcherImageTag }}"
+        - name: FETCHER_IMAGE_PULL_POLICY
+          value: "{{ .Values.pullPolicy }}"
+      serviceAccount: fission-svc
+
+---
+apiVersion: extensions/v1beta1
+kind: Deployment
+metadata:
+  name: kubewatcher
+  labels:
+    chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
+spec:
+  replicas: 1
+  template:
+    metadata:
+      labels:
+        svc: kubewatcher
+    spec:
+      containers:
+      - name: kubewatcher
+        image: "{{ .Values.image }}:{{ .Values.imageTag }}"
+        imagePullPolicy: {{ .Values.pullPolicy }}
+        command: ["/fission-bundle"]
+        args: ["--kubewatcher"]
+      serviceAccount: fission-svc
+
+---
+apiVersion: extensions/v1beta1
+kind: Deployment
+metadata:
+  name: timer
+  labels:
+    chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
+spec:
+  replicas: 1
+  template:
+    metadata:
+      labels:
+        svc: timer
+    spec:
+      containers:
+      - name: timer
+        image: "{{ .Values.image }}:{{ .Values.imageTag }}"
+        imagePullPolicy: {{ .Values.pullPolicy }}
+        command: ["/fission-bundle"]
+        args: ["--timer"]
+      serviceAccount: fission-svc

charts/fission-core/templates/svc.yaml

@@ -0,0 +1,32 @@
+apiVersion: v1
+kind: Service
+metadata:
+  name: router
+  labels:
+    svc: router
+    chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
+spec:
+  type: {{ .Values.serviceType }}
+  ports:
+  - port: 80
+    targetPort: 8888
+    nodePort: {{ .Values.routerPort }}
+  selector:
+    svc: router
+
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: controller
+  labels:
+    svc: controller
+    chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
+spec:
+  type: {{ .Values.serviceType }}
+  ports:
+  - port: 80
+    targetPort: 8888
+    nodePort: {{ .Values.controllerPort }}
+  selector:
+    svc: controller

charts/fission-core/values.yaml

@@ -0,0 +1,35 @@
+#
+# Fission chart configuration
+# 
+
+## Kubernetes configuration
+## For minikube, set this to NodePort, elsewhere use LoadBalancer.
+serviceType: LoadBalancer
+
+## Fission image repository
+image: fission/fission-bundle
+
+## Fission image version
+imageTag: v0.2.0-20170822
+
+## Image pull policy
+pullPolicy: IfNotPresent
+
+## Fission fetcher repository
+fetcherImage: fission/fetcher
+
+## Fission fetcher image version
+fetcherImageTag: v0.2.0-20170822
+
+## Port at which Fission controller service should be exposed
+controllerPort: 31313
+
+## Port at which Fission router service should be exposed
+routerPort: 31314
+
+## Namespace in which to run fission functions (this is different from
+## the release namespace)
+functionNamespace: fission-function
+
+## Set up openshift RBAC rule
+openshift: false

common.go

@@ -20,11 +20,7 @@ import (
 	"fmt"
 )
 
-func UrlForFunction(m *Metadata) string {
+func UrlForFunction(name string) string {
 	prefix := "/fission-function"
-	if len(m.Uid) > 0 {
-		return fmt.Sprintf("%v/%v/%v", prefix, m.Name, m.Uid)
-	} else {
-		return fmt.Sprintf("%v/%v", prefix, m.Name)
-	}
+	return fmt.Sprintf("%v/%v", prefix, name)
 }

controller/api.go

@@ -21,32 +21,46 @@ import (
 	"net/http"
 	"os"
 	"runtime/debug"
+	"strings"
 
-	log "github.com/Sirupsen/logrus"
 	"github.com/gorilla/handlers"
 	"github.com/gorilla/mux"
+	log "github.com/sirupsen/logrus"
+	kerrors "k8s.io/client-go/1.5/pkg/api/errors"
 
 	"github.com/fission/fission"
+	"github.com/fission/fission/fission/logdb"
+	"github.com/fission/fission/tpr"
 )
 
-type API struct {
-	FunctionStore
-	HTTPTriggerStore
-	EnvironmentStore
-	WatchStore
-}
-
-func MakeAPI(rs *ResourceStore) *API {
-	api := &API{
-		FunctionStore:    FunctionStore{ResourceStore: *rs},
-		HTTPTriggerStore: HTTPTriggerStore{ResourceStore: *rs},
-		EnvironmentStore: EnvironmentStore{ResourceStore: *rs},
-		WatchStore:       WatchStore{ResourceStore: *rs},
+type (
+	API struct {
+		fissionClient     *tpr.FissionClient
+		storageServiceUrl string
 	}
-	return api
+
+	logDBConfig struct {
+		httpURL  string
+		username string
+		password string
+	}
+)
+
+func MakeAPI() (*API, error) {
+	api, err := makeTPRBackedAPI()
+
+	u := os.Getenv("STORAGE_SERVICE_URL")
+	if len(u) > 0 {
+		api.storageServiceUrl = strings.TrimSuffix(u, "/")
+	} else {
+		api.storageServiceUrl = "http://storagesvc"
+	}
+
+	return api, err
 }
 
 func (api *API) respondWithSuccess(w http.ResponseWriter, resp []byte) {
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
 	_, err := w.Write(resp)
 	if err != nil {
 		// this will probably fail too, but try anyway
@@ -56,42 +70,96 @@ func (api *API) respondWithSuccess(w http.ResponseWriter, resp []byte) {
 
 func (api *API) respondWithError(w http.ResponseWriter, err error) {
 	debug.PrintStack()
+
+	// this error type comes with an HTTP code, so just use that
+	se, ok := err.(*kerrors.StatusError)
+	if ok {
+		http.Error(w, string(se.ErrStatus.Reason), int(se.ErrStatus.Code))
+		return
+	}
+
 	code, msg := fission.GetHTTPError(err)
 	log.Errorf("Error: %v: %v", code, msg)
 	http.Error(w, msg, code)
 }
 
+func (api *API) getLogDBConfig(dbType string) logDBConfig {
+	dbType = strings.ToUpper(dbType)
+	// retrieve db auth config from the env
+	url := os.Getenv(fmt.Sprintf("%s_URL", dbType))
+	if url == "" {
+		// set up default database url
+		url = logdb.INFLUXDB_URL
+	}
+	username := os.Getenv(fmt.Sprintf("%s_USERNAME", dbType))
+	password := os.Getenv(fmt.Sprintf("%s_PASSWORD", dbType))
+	return logDBConfig{
+		httpURL:  url,
+		username: username,
+		password: password,
+	}
+}
+
 func (api *API) HomeHandler(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
 	fmt.Fprintf(w, "{\"message\": \"Fission API\", \"version\": \"0.1.0\"}\n")
 }
 
+func (api *API) ApiVersionMismatchHandler(w http.ResponseWriter, r *http.Request) {
+	err := fission.MakeError(fission.ErrorNotFound, "Fission server supports API v2 only - v1 is not supported. Please upgrade your Fission client / CLI")
+	api.respondWithError(w, err)
+}
+
 func (api *API) Serve(port int) {
 	r := mux.NewRouter()
+	// Give a useful error message if an older CLI attempts to make a request
+	r.HandleFunc(`/v1/{rest:[a-zA-Z0-9=\-\/]+}`, api.ApiVersionMismatchHandler)
 	r.HandleFunc("/", api.HomeHandler)
 
-	r.HandleFunc("/v1/functions", api.FunctionApiList).Methods("GET")
-	r.HandleFunc("/v1/functions", api.FunctionApiCreate).Methods("POST")
-	r.HandleFunc("/v1/functions/{function}", api.FunctionApiGet).Methods("GET")
-	r.HandleFunc("/v1/functions/{function}", api.FunctionApiUpdate).Methods("PUT")
-	r.HandleFunc("/v1/functions/{function}", api.FunctionApiDelete).Methods("DELETE")
+	r.HandleFunc("/v2/packages", api.PackageApiList).Methods("GET")
+	r.HandleFunc("/v2/packages", api.PackageApiCreate).Methods("POST")
+	r.HandleFunc("/v2/packages/{package}", api.PackageApiGet).Methods("GET")
+	r.HandleFunc("/v2/packages/{package}", api.PackageApiUpdate).Methods("PUT")
+	r.HandleFunc("/v2/packages/{package}", api.PackageApiDelete).Methods("DELETE")
 
-	r.HandleFunc("/v1/triggers/http", api.HTTPTriggerApiList).Methods("GET")
-	r.HandleFunc("/v1/triggers/http", api.HTTPTriggerApiCreate).Methods("POST")
-	r.HandleFunc("/v1/triggers/http/{httpTrigger}", api.HTTPTriggerApiGet).Methods("GET")
-	r.HandleFunc("/v1/triggers/http/{httpTrigger}", api.HTTPTriggerApiUpdate).Methods("PUT")
-	r.HandleFunc("/v1/triggers/http/{httpTrigger}", api.HTTPTriggerApiDelete).Methods("DELETE")
+	r.HandleFunc("/v2/functions", api.FunctionApiList).Methods("GET")
+	r.HandleFunc("/v2/functions", api.FunctionApiCreate).Methods("POST")
+	r.HandleFunc("/v2/functions/{function}", api.FunctionApiGet).Methods("GET")
+	r.HandleFunc("/v2/functions/{function}", api.FunctionApiUpdate).Methods("PUT")
+	r.HandleFunc("/v2/functions/{function}", api.FunctionApiDelete).Methods("DELETE")
 
-	r.HandleFunc("/v1/environments", api.EnvironmentApiList).Methods("GET")
-	r.HandleFunc("/v1/environments", api.EnvironmentApiCreate).Methods("POST")
-	r.HandleFunc("/v1/environments/{environment}", api.EnvironmentApiGet).Methods("GET")
-	r.HandleFunc("/v1/environments/{environment}", api.EnvironmentApiUpdate).Methods("PUT")
-	r.HandleFunc("/v1/environments/{environment}", api.EnvironmentApiDelete).Methods("DELETE")
+	r.HandleFunc("/v2/triggers/http", api.HTTPTriggerApiList).Methods("GET")
+	r.HandleFunc("/v2/triggers/http", api.HTTPTriggerApiCreate).Methods("POST")
+	r.HandleFunc("/v2/triggers/http/{httpTrigger}", api.HTTPTriggerApiGet).Methods("GET")
+	r.HandleFunc("/v2/triggers/http/{httpTrigger}", api.HTTPTriggerApiUpdate).Methods("PUT")
+	r.HandleFunc("/v2/triggers/http/{httpTrigger}", api.HTTPTriggerApiDelete).Methods("DELETE")
 
-	r.HandleFunc("/v1/watches", api.WatchApiList).Methods("GET")
-	r.HandleFunc("/v1/watches", api.WatchApiCreate).Methods("POST")
-	r.HandleFunc("/v1/watches/{watch}", api.WatchApiGet).Methods("GET")
-	r.HandleFunc("/v1/watches/{watch}", api.WatchApiUpdate).Methods("PUT")
-	r.HandleFunc("/v1/watches/{watch}", api.WatchApiDelete).Methods("DELETE")
+	r.HandleFunc("/v2/environments", api.EnvironmentApiList).Methods("GET")
+	r.HandleFunc("/v2/environments", api.EnvironmentApiCreate).Methods("POST")
+	r.HandleFunc("/v2/environments/{environment}", api.EnvironmentApiGet).Methods("GET")
+	r.HandleFunc("/v2/environments/{environment}", api.EnvironmentApiUpdate).Methods("PUT")
+	r.HandleFunc("/v2/environments/{environment}", api.EnvironmentApiDelete).Methods("DELETE")
+
+	r.HandleFunc("/v2/watches", api.WatchApiList).Methods("GET")
+	r.HandleFunc("/v2/watches", api.WatchApiCreate).Methods("POST")
+	r.HandleFunc("/v2/watches/{watch}", api.WatchApiGet).Methods("GET")
+	r.HandleFunc("/v2/watches/{watch}", api.WatchApiUpdate).Methods("PUT")
+	r.HandleFunc("/v2/watches/{watch}", api.WatchApiDelete).Methods("DELETE")
+
+	r.HandleFunc("/v2/triggers/time", api.TimeTriggerApiList).Methods("GET")
+	r.HandleFunc("/v2/triggers/time", api.TimeTriggerApiCreate).Methods("POST")
+	r.HandleFunc("/v2/triggers/time/{timeTrigger}", api.TimeTriggerApiGet).Methods("GET")
+	r.HandleFunc("/v2/triggers/time/{timeTrigger}", api.TimeTriggerApiUpdate).Methods("PUT")
+	r.HandleFunc("/v2/triggers/time/{timeTrigger}", api.TimeTriggerApiDelete).Methods("DELETE")
+
+	r.HandleFunc("/v2/triggers/messagequeue", api.MessageQueueTriggerApiList).Methods("GET")
+	r.HandleFunc("/v2/triggers/messagequeue", api.MessageQueueTriggerApiCreate).Methods("POST")
+	r.HandleFunc("/v2/triggers/messagequeue/{mqTrigger}", api.MessageQueueTriggerApiGet).Methods("GET")
+	r.HandleFunc("/v2/triggers/messagequeue/{mqTrigger}", api.MessageQueueTriggerApiUpdate).Methods("PUT")
+	r.HandleFunc("/v2/triggers/messagequeue/{mqTrigger}", api.MessageQueueTriggerApiDelete).Methods("DELETE")
+
+	r.HandleFunc("/proxy/{dbType}", api.FunctionLogsApiPost).Methods("POST")
+	r.HandleFunc("/proxy/storage/v1/archive", api.StorageServiceProxy)
 
 	address := fmt.Sprintf(":%v", port)
 

controller/api_test.go

@@ -19,81 +19,92 @@ package controller
 import (
 	"flag"
 	"io/ioutil"
+	"log"
 	"net/http"
 	"os"
 	"testing"
 	"time"
 
-	log "github.com/Sirupsen/logrus"
-	etcdClient "github.com/coreos/etcd/client"
-	"golang.org/x/net/context"
+	"k8s.io/client-go/1.5/pkg/api"
 
 	"github.com/fission/fission"
 	"github.com/fission/fission/controller/client"
+	"github.com/fission/fission/tpr"
 )
 
 var g struct {
 	client *client.Client
 }
 
-func TestFunctionApi(t *testing.T) {
-	log.SetFormatter(&log.TextFormatter{DisableColors: true})
-
-	testFunc := &fission.Function{
-		Metadata: fission.Metadata{
-			Name: "foo",
-			Uid:  "",
-		},
-		Environment: fission.Metadata{
-			Name: "nodejs",
-			Uid:  "xxx",
-		},
-		Code: "code1",
+func panicIf(err error) {
+	if err != nil {
+		log.Panicf("err: %v", err)
 	}
+}
 
-	m, err := g.client.FunctionCreate(testFunc)
-	panicIf(err)
-	uid1 := m.Uid
-	//log.Printf("Created function %v: %v", m.Name, m.Uid)
+func assert(c bool, msg string) {
+	if !c {
+		log.Fatalf("assert failed: %v", msg)
+	}
+}
 
-	code, err := g.client.FunctionGetRaw(m)
-	panicIf(err)
-	assert(string(code) == testFunc.Code, "code from FunctionGetRaw must match created function")
+func assertNameReuseFailure(err error, name string) {
+	assert(err != nil, "recreating "+name+" with same name must fail")
+	fe, ok := err.(fission.Error)
+	assert(ok, "error must be a fission Error")
+	assert(fe.Code == fission.ErrorNameExists, "error must be a name exists error")
+}
 
-	testFunc.Code = "code2"
-	m, err = g.client.FunctionUpdate(testFunc)
-	panicIf(err)
-	uid2 := m.Uid
-	//log.Printf("Updated function %v: %v", m.Name, m.Uid)
+func assertNotFoundFailure(err error, name string) {
+	assert(err != nil, "requesting a non-existent "+name+" must fail")
+	fe, ok := err.(fission.Error)
+	assert(ok, "error must be a fission Error")
+	if fe.Code != fission.ErrorNotFound {
+		log.Fatalf("error must be a not found error: %v", fe)
+	}
+}
 
-	m.Uid = uid1
-	testFunc.Code = "code1"
-	f, err := g.client.FunctionGet(m)
+func assertCronSpecFails(err error) {
+	assert(err != nil, "using an invalid cron spec must fail")
+	fe, ok := err.(fission.Error)
+	assert(ok, "error must be a fission Error")
+	assert(fe.Code == fission.ErrorInvalidArgument, "error must be a invalid argument error")
+}
+
+func TestFunctionApi(t *testing.T) {
+	name1 := "foo"
+	name2 := "bar"
+
+	testFunc := &tpr.Function{
+		Metadata: api.ObjectMeta{
+			Name:      name1,
+			Namespace: api.NamespaceDefault,
+		},
+		Spec: fission.FunctionSpec{
+			EnvironmentName: "nodejs",
+			Deployment: fission.FunctionPackageRef{
+				FunctionName: "xxx",
+			},
+		},
+	}
+	_, err := g.client.FunctionGet(&api.ObjectMeta{
+		Name:      testFunc.Metadata.Name,
+		Namespace: api.NamespaceDefault,
+	})
+	assertNotFoundFailure(err, "function")
+
+	_, err = g.client.FunctionCreate(testFunc)
 	panicIf(err)
 
-	testFunc.Metadata.Uid = m.Uid
-	//log.Printf("f = %#v", f)
-	//log.Printf("testFunc = %#v", testFunc)
-	assert(*f == *testFunc, "first version should match when read by uid")
+	_, err = g.client.FunctionCreate(testFunc)
+	assertNameReuseFailure(err, "function")
 
-	m.Uid = uid2
-	testFunc.Metadata.Uid = m.Uid
-	testFunc.Code = "code2"
-	f, err = g.client.FunctionGet(m)
+	testFunc.Spec.Deployment.FunctionName = "yyy"
+	_, err = g.client.FunctionUpdate(testFunc)
 	panicIf(err)
 
-	assert(*f == *testFunc, "second version should match when read by uid")
-
-	m.Uid = ""
-	testFunc.Metadata.Uid = uid2
-	testFunc.Code = "code2"
-	f, err = g.client.FunctionGet(m)
-	panicIf(err)
-
-	assert(*f == *testFunc, "second version should match when read as latest")
-
-	testFunc.Metadata.Name = "bar"
-	m, err = g.client.FunctionCreate(testFunc)
+	testFunc.Metadata.Name = name2
+	_, err = g.client.FunctionCreate(testFunc)
 	panicIf(err)
 
 	funcs, err := g.client.FunctionList()
@@ -101,47 +112,69 @@ func TestFunctionApi(t *testing.T) {
 	assert(len(funcs) == 2,
 		"created two functions, but didn't find them")
 
-	err = g.client.FunctionDelete(&fission.Metadata{Name: "foo"})
+	funcs_url := g.client.Url + "/v2/functions"
+	resp, err := http.Get(funcs_url)
 	panicIf(err)
-	err = g.client.FunctionDelete(&fission.Metadata{Name: "bar"})
+	defer resp.Body.Close()
+	assert(resp.StatusCode == 200, "http get status code on /v1/functions")
+
+	var found bool = false
+	for _, b := range resp.Header["Content-Type"] {
+		if b == "application/json; charset=utf-8" {
+			found = true
+		}
+	}
+	assert(found, "incorrect response content type")
+
+	err = g.client.FunctionDelete(&api.ObjectMeta{Name: name1, Namespace: api.NamespaceDefault})
+	panicIf(err)
+	err = g.client.FunctionDelete(&api.ObjectMeta{Name: name2, Namespace: api.NamespaceDefault})
 	panicIf(err)
 }
 
 func TestHTTPTriggerApi(t *testing.T) {
-	testTrigger := &fission.HTTPTrigger{
-		Metadata: fission.Metadata{
-			Name: "xxx",
-			Uid:  "yyy",
+	testTrigger := &tpr.Httptrigger{
+		Metadata: api.ObjectMeta{
+			Name:      "foo",
+			Namespace: api.NamespaceDefault,
 		},
-		UrlPattern: "/hello",
-		Function: fission.Metadata{
-			Name: "foo",
-			Uid:  "",
+		Spec: fission.HTTPTriggerSpec{
+			RelativeURL: "/hello",
+			FunctionReference: fission.FunctionReference{
+				Type: fission.FunctionReferenceTypeFunctionName,
+				Name: "foo",
+			},
 		},
 	}
+	_, err := g.client.HTTPTriggerGet(&api.ObjectMeta{
+		Name:      testTrigger.Metadata.Name,
+		Namespace: api.NamespaceDefault,
+	})
+	assertNotFoundFailure(err, "httptrigger")
+
 	m, err := g.client.HTTPTriggerCreate(testTrigger)
 	panicIf(err)
 	defer g.client.HTTPTriggerDelete(m)
 
+	_, err = g.client.HTTPTriggerCreate(testTrigger)
+	assertNameReuseFailure(err, "httptrigger")
+
 	tr, err := g.client.HTTPTriggerGet(m)
 	panicIf(err)
-	testTrigger.Metadata.Uid = m.Uid
-	assert(*testTrigger == *tr, "trigger should match after reading")
+	assert(testTrigger.Spec == tr.Spec, "trigger should match after reading")
 
-	testTrigger.UrlPattern = "/hi"
-	m2, err := g.client.HTTPTriggerUpdate(testTrigger)
+	testTrigger.Spec.RelativeURL = "/hi"
+	_, err = g.client.HTTPTriggerUpdate(testTrigger)
 	panicIf(err)
 
-	m.Uid = m2.Uid
-	tr, err = g.client.HTTPTriggerGet(m)
-	panicIf(err)
-	testTrigger.Metadata.Uid = m.Uid
-	assert(*testTrigger == *tr, "trigger should match after reading")
-
 	testTrigger.Metadata.Name = "yyy"
-	m, err = g.client.HTTPTriggerCreate(testTrigger)
+	_, err = g.client.HTTPTriggerCreate(testTrigger)
+	assert(err != nil, "duplicate trigger should not be allowed")
+
+	testTrigger.Spec.RelativeURL = "/hi2"
+	m2, err := g.client.HTTPTriggerCreate(testTrigger)
 	panicIf(err)
-	defer g.client.HTTPTriggerDelete(m)
+	defer g.client.HTTPTriggerDelete(m2)
 
 	ts, err := g.client.HTTPTriggerList()
 	panicIf(err)
@@ -149,36 +182,42 @@ func TestHTTPTriggerApi(t *testing.T) {
 }
 
 func TestEnvironmentApi(t *testing.T) {
-	testEnv := &fission.Environment{
-		Metadata: fission.Metadata{
-			Name: "xxx",
-			Uid:  "yyy",
+	testEnv := &tpr.Environment{
+		Metadata: api.ObjectMeta{
+			Name:      "foo",
+			Namespace: api.NamespaceDefault,
+		},
+		Spec: fission.EnvironmentSpec{
+			Runtime: fission.Runtime{
+				Image: "gcr.io/xyz",
+			},
 		},
-		RunContainerImageUrl: "gcr.io/xyz",
 	}
+	_, err := g.client.EnvironmentGet(&api.ObjectMeta{
+		Name:      testEnv.Metadata.Name,
+		Namespace: api.NamespaceDefault,
+	})
+	assertNotFoundFailure(err, "environment")
+
 	m, err := g.client.EnvironmentCreate(testEnv)
 	panicIf(err)
 	defer g.client.EnvironmentDelete(m)
 
-	tr, err := g.client.EnvironmentGet(m)
-	panicIf(err)
-	testEnv.Metadata.Uid = m.Uid
-	assert(*testEnv == *tr, "env should match after reading")
+	_, err = g.client.EnvironmentCreate(testEnv)
+	assertNameReuseFailure(err, "environment")
 
-	testEnv.RunContainerImageUrl = "/hi"
-	m2, err := g.client.EnvironmentUpdate(testEnv)
+	e, err := g.client.EnvironmentGet(m)
+	panicIf(err)
+	assert(testEnv.Spec == e.Spec, "env should match after reading")
+
+	testEnv.Spec.Runtime.Image = "another-img"
+	_, err = g.client.EnvironmentUpdate(testEnv)
 	panicIf(err)
 
-	m.Uid = m2.Uid
-	tr, err = g.client.EnvironmentGet(m)
+	testEnv.Metadata.Name = "bar"
+	m2, err := g.client.EnvironmentCreate(testEnv)
 	panicIf(err)
-	testEnv.Metadata.Uid = m.Uid
-	assert(*testEnv == *tr, "env should match after reading")
-
-	testEnv.Metadata.Name = "yyy"
-	m, err = g.client.EnvironmentCreate(testEnv)
-	panicIf(err)
-	defer g.client.EnvironmentDelete(m)
+	defer g.client.EnvironmentDelete(m2)
 
 	ts, err := g.client.EnvironmentList()
 	panicIf(err)
@@ -186,30 +225,38 @@ func TestEnvironmentApi(t *testing.T) {
 }
 
 func TestWatchApi(t *testing.T) {
-	testWatch := &fission.Watch{
-		Metadata: fission.Metadata{
-			Name: "xxx",
-			Uid:  "yyy",
+	testWatch := &tpr.Kuberneteswatchtrigger{
+		Metadata: api.ObjectMeta{
+			Name:      "xxx",
+			Namespace: api.NamespaceDefault,
 		},
-		Namespace:     "default",
-		ObjType:       "pod",
-		LabelSelector: "",
-		FieldSelector: "",
-		Function: fission.Metadata{
-			Name: "foo",
-			Uid:  "",
+		Spec: fission.KubernetesWatchTriggerSpec{
+			Namespace: "default",
+			Type:      "pod",
+			FunctionReference: fission.FunctionReference{
+				Type: fission.FunctionReferenceTypeFunctionName,
+				Name: "foo",
+			},
 		},
-		Target: "",
 	}
+	_, err := g.client.WatchGet(&api.ObjectMeta{
+		Name:      testWatch.Metadata.Name,
+		Namespace: api.NamespaceDefault,
+	})
+	assertNotFoundFailure(err, "watch")
+
 	m, err := g.client.WatchCreate(testWatch)
 	panicIf(err)
 	defer g.client.WatchDelete(m)
 
+	_, err = g.client.WatchCreate(testWatch)
+	assertNameReuseFailure(err, "watch")
+
 	w, err := g.client.WatchGet(m)
 	panicIf(err)
-	testWatch.Metadata.Uid = m.Uid
-	w.Target = ""
-	assert(*testWatch == *w, "watch should match after reading")
+	assert((testWatch.Spec.Namespace == w.Spec.Namespace &&
+		testWatch.Spec.Type == w.Spec.Type &&
+		testWatch.Spec.FunctionReference == w.Spec.FunctionReference), "watch should match after reading")
 
 	testWatch.Metadata.Name = "yyy"
 	m2, err := g.client.WatchCreate(testWatch)
@@ -221,26 +268,75 @@ func TestWatchApi(t *testing.T) {
 	assert(len(ws) == 2, "created two envs, but didn't find them")
 }
 
+func TestTimeTriggerApi(t *testing.T) {
+	testTrigger := &tpr.Timetrigger{
+		Metadata: api.ObjectMeta{
+			Name:      "xxx",
+			Namespace: api.NamespaceDefault,
+		},
+		Spec: fission.TimeTriggerSpec{
+			Cron: "0 30 * * * *",
+			FunctionReference: fission.FunctionReference{
+				Type: fission.FunctionReferenceTypeFunctionName,
+				Name: "asdf",
+			},
+		},
+	}
+	_, err := g.client.TimeTriggerGet(&api.ObjectMeta{Name: testTrigger.Metadata.Name})
+	assertNotFoundFailure(err, "trigger")
+
+	m, err := g.client.TimeTriggerCreate(testTrigger)
+	panicIf(err)
+	defer g.client.TimeTriggerDelete(m)
+
+	_, err = g.client.TimeTriggerCreate(testTrigger)
+	assertNameReuseFailure(err, "trigger")
+
+	tr, err := g.client.TimeTriggerGet(m)
+	panicIf(err)
+	assert(testTrigger.Spec == tr.Spec, "trigger should match after reading")
+
+	testTrigger.Spec.Cron = "@hourly"
+	_, err = g.client.TimeTriggerUpdate(testTrigger)
+	panicIf(err)
+
+	testTrigger.Metadata.Name = "yyy"
+	testTrigger.Spec.Cron = "Not valid cron spec"
+	_, err = g.client.TimeTriggerCreate(testTrigger)
+	assertCronSpecFails(err)
+
+	ts, err := g.client.TimeTriggerList()
+	panicIf(err)
+	assert(len(ts) == 1, "created one trigger, but didn't find it")
+}
+
 func TestMain(m *testing.M) {
 	flag.Parse()
 
-	fileStore, ks, rs := getTestResourceStore()
-	defer os.RemoveAll(fileStore.root)
+	// skip test if no cluster available for testing
+	kubeconfig := os.Getenv("KUBECONFIG")
+	if len(kubeconfig) == 0 {
+		log.Println("Skipping test, no kubernetes cluster")
+		return
+	}
 
-	api := MakeAPI(rs)
+	go Start(8888)
+
+	time.Sleep(time.Second)
 	g.client = client.MakeClient("http://localhost:8888")
 
-	ks.Delete(context.Background(), "Function", &etcdClient.DeleteOptions{Recursive: true})
-	ks.Delete(context.Background(), "HTTPTrigger", &etcdClient.DeleteOptions{Recursive: true})
-	ks.Delete(context.Background(), "Environment", &etcdClient.DeleteOptions{Recursive: true})
-	ks.Delete(context.Background(), "Watch", &etcdClient.DeleteOptions{Recursive: true})
-
-	go api.Serve(8888)
-	time.Sleep(500 * time.Millisecond)
-
 	resp, err := http.Get("http://localhost:8888/")
 	panicIf(err)
 	assert(resp.StatusCode == 200, "http get status code on root")
+
+	var found bool = false
+	for _, b := range resp.Header["Content-Type"] {
+		if b == "application/json; charset=utf-8" {
+			found = true
+		}
+	}
+	assert(found, "incorrect response content type")
+
 	_, err = ioutil.ReadAll(resp.Body)
 	panicIf(err)
 

controller/client/client.go

@@ -18,16 +18,11 @@ package client
 
 import (
 	"bytes"
-	"encoding/base64"
-	"encoding/json"
 	"errors"
-	"fmt"
 	"io/ioutil"
 	"net/http"
 	"strings"
 
-	log "github.com/Sirupsen/logrus"
-
 	"github.com/fission/fission"
 )
 
@@ -75,474 +70,21 @@ func (c *Client) put(relativeUrl string, contentType string, body []byte) (*http
 }
 
 func (c *Client) url(relativeUrl string) string {
-	return c.Url + "/v1/" + relativeUrl
+	return c.Url + "/v2/" + relativeUrl
 }
 
 func (c *Client) handleResponse(resp *http.Response) ([]byte, error) {
 	if resp.StatusCode != 200 {
-		var errCode int
-		switch resp.StatusCode {
-		case 403:
-			errCode = fission.ErrorNotAuthorized
-		case 404:
-			errCode = fission.ErrorNotFound
-		case 400:
-			errCode = fission.ErrorInvalidArgument
-		default:
-			errCode = fission.ErrorInternal
-		}
-		return nil, fission.MakeError(errCode,
-			fmt.Sprintf("HTTP error %v", resp.StatusCode))
+		return nil, fission.MakeErrorFromHTTP(resp)
 	}
 	body, err := ioutil.ReadAll(resp.Body)
 	return body, err
 }
 
-func (c *Client) FunctionCreate(f *fission.Function) (*fission.Metadata, error) {
-	orig := f.Code
-	f.Code = base64.StdEncoding.EncodeToString([]byte(f.Code))
-	defer func() { f.Code = orig }()
-
-	reqbody, err := json.Marshal(f)
-	if err != nil {
-		return nil, err
+func (c *Client) handleCreateResponse(resp *http.Response) ([]byte, error) {
+	if resp.StatusCode != 201 {
+		return nil, fission.MakeErrorFromHTTP(resp)
 	}
-
-	resp, err := http.Post(c.url("functions"), "application/json", bytes.NewReader(reqbody))
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	body, err := c.handleResponse(resp)
-	if err != nil {
-		log.WithFields(log.Fields{
-			"name": f.Metadata.Name,
-			"err":  err,
-		}).Error("Failed to create function")
-		return nil, err
-	}
-
-	var m fission.Metadata
-	err = json.Unmarshal(body, &m)
-	if err != nil {
-		return nil, err
-	}
-
-	return &m, nil
-}
-
-func (c *Client) FunctionGet(m *fission.Metadata) (*fission.Function, error) {
-	relativeUrl := fmt.Sprintf("functions/%v", m.Name)
-	if len(m.Uid) > 0 {
-		relativeUrl += fmt.Sprintf("?uid=%v", m.Uid)
-	}
-
-	resp, err := http.Get(c.url(relativeUrl))
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	body, err := c.handleResponse(resp)
-	if err != nil {
-		return nil, err
-	}
-
-	var f fission.Function
-	err = json.Unmarshal(body, &f)
-	if err != nil {
-		return nil, err
-	}
-
-	dec, err := base64.StdEncoding.DecodeString(f.Code)
-	if err != nil {
-		return nil, err
-	}
-	f.Code = string(dec)
-
-	return &f, nil
-}
-
-func (c *Client) FunctionGetRaw(m *fission.Metadata) ([]byte, error) {
-	relativeUrl := fmt.Sprintf("functions/%v?raw=1", m.Name)
-	if len(m.Uid) > 0 {
-		relativeUrl += fmt.Sprintf("&uid=%v", m.Uid)
-	}
-
-	resp, err := http.Get(c.url(relativeUrl))
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	return c.handleResponse(resp)
-}
-
-func (c *Client) FunctionUpdate(f *fission.Function) (*fission.Metadata, error) {
-	orig := f.Code
-	f.Code = base64.StdEncoding.EncodeToString([]byte(f.Code))
-	defer func() { f.Code = orig }()
-
-	reqbody, err := json.Marshal(f)
-	if err != nil {
-		return nil, err
-	}
-	relativeUrl := fmt.Sprintf("functions/%v", f.Metadata.Name)
-
-	resp, err := c.put(relativeUrl, "application/json", reqbody)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	body, err := c.handleResponse(resp)
-	if err != nil {
-		return nil, err
-	}
-
-	var m fission.Metadata
-	err = json.Unmarshal(body, &m)
-	if err != nil {
-		return nil, err
-	}
-	return &m, nil
-}
-
-func (c *Client) FunctionDelete(m *fission.Metadata) error {
-	relativeUrl := fmt.Sprintf("functions/%v", m.Name)
-	if len(m.Uid) > 0 {
-		relativeUrl += fmt.Sprintf("?uid=%v", m.Uid)
-	}
-	err := c.delete(relativeUrl)
-	return err
-}
-
-func (c *Client) FunctionList() ([]fission.Function, error) {
-	resp, err := http.Get(c.url("functions"))
-	if err != nil {
-		return nil, err
-	}
-
-	body, err := c.handleResponse(resp)
-	if err != nil {
-		return nil, err
-	}
-
-	funcs := make([]fission.Function, 0)
-	err = json.Unmarshal(body, &funcs)
-	if err != nil {
-		return nil, err
-	}
-
-	return funcs, nil
-}
-
-func (c *Client) HTTPTriggerCreate(t *fission.HTTPTrigger) (*fission.Metadata, error) {
-	reqbody, err := json.Marshal(t)
-	if err != nil {
-		return nil, err
-	}
-
-	resp, err := http.Post(c.url("triggers/http"), "application/json", bytes.NewReader(reqbody))
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	body, err := c.handleResponse(resp)
-	if err != nil {
-		log.WithFields(log.Fields{
-			"name": t.Metadata.Name,
-			"err":  err,
-		}).Error("Failed to create http trigger")
-		return nil, err
-	}
-
-	var m fission.Metadata
-	err = json.Unmarshal(body, &m)
-	if err != nil {
-		return nil, err
-	}
-
-	return &m, nil
-}
-
-func (c *Client) HTTPTriggerGet(m *fission.Metadata) (*fission.HTTPTrigger, error) {
-	relativeUrl := fmt.Sprintf("triggers/http/%v", m.Name)
-	if len(m.Uid) > 0 {
-		relativeUrl += fmt.Sprintf("?uid=%v", m.Uid)
-	}
-
-	resp, err := http.Get(c.url(relativeUrl))
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	body, err := c.handleResponse(resp)
-	if err != nil {
-		return nil, err
-	}
-
-	var t fission.HTTPTrigger
-	err = json.Unmarshal(body, &t)
-	if err != nil {
-		return nil, err
-	}
-
-	return &t, nil
-}
-
-func (c *Client) HTTPTriggerUpdate(t *fission.HTTPTrigger) (*fission.Metadata, error) {
-	reqbody, err := json.Marshal(t)
-	if err != nil {
-		return nil, err
-	}
-	relativeUrl := fmt.Sprintf("triggers/http/%v", t.Metadata.Name)
-
-	resp, err := c.put(relativeUrl, "application/json", reqbody)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	body, err := c.handleResponse(resp)
-	if err != nil {
-		return nil, err
-	}
-
-	var m fission.Metadata
-	err = json.Unmarshal(body, &m)
-	if err != nil {
-		return nil, err
-	}
-	return &m, nil
-}
-
-func (c *Client) HTTPTriggerDelete(m *fission.Metadata) error {
-	relativeUrl := fmt.Sprintf("triggers/http/%v", m.Name)
-	if len(m.Uid) > 0 {
-		relativeUrl += fmt.Sprintf("?uid=%v", m.Uid)
-	}
-	err := c.delete(relativeUrl)
-	return err
-}
-
-func (c *Client) HTTPTriggerList() ([]fission.HTTPTrigger, error) {
-	resp, err := http.Get(c.url("triggers/http"))
-	if err != nil {
-		return nil, err
-	}
-
-	body, err := c.handleResponse(resp)
-	if err != nil {
-		return nil, err
-	}
-
-	triggers := make([]fission.HTTPTrigger, 0)
-	err = json.Unmarshal(body, &triggers)
-	if err != nil {
-		return nil, err
-	}
-
-	return triggers, nil
-}
-
-func (c *Client) EnvironmentCreate(env *fission.Environment) (*fission.Metadata, error) {
-	reqbody, err := json.Marshal(env)
-	if err != nil {
-		return nil, err
-	}
-
-	resp, err := http.Post(c.url("environments"), "application/json", bytes.NewReader(reqbody))
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	body, err := c.handleResponse(resp)
-	if err != nil {
-		log.WithFields(log.Fields{
-			"name": env.Metadata.Name,
-			"err":  err,
-		}).Error("Failed to create environment")
-		return nil, err
-	}
-
-	var m fission.Metadata
-	err = json.Unmarshal(body, &m)
-	if err != nil {
-		return nil, err
-	}
-
-	return &m, nil
-}
-
-func (c *Client) EnvironmentGet(m *fission.Metadata) (*fission.Environment, error) {
-	relativeUrl := fmt.Sprintf("environments/%v", m.Name)
-	if len(m.Uid) > 0 {
-		relativeUrl += fmt.Sprintf("?uid=%v", m.Uid)
-	}
-
-	resp, err := http.Get(c.url(relativeUrl))
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	body, err := c.handleResponse(resp)
-	if err != nil {
-		return nil, err
-	}
-
-	var env fission.Environment
-	err = json.Unmarshal(body, &env)
-	if err != nil {
-		return nil, err
-	}
-
-	return &env, nil
-}
-
-func (c *Client) EnvironmentUpdate(env *fission.Environment) (*fission.Metadata, error) {
-	reqbody, err := json.Marshal(env)
-	if err != nil {
-		return nil, err
-	}
-	relativeUrl := fmt.Sprintf("environments/%v", env.Metadata.Name)
-
-	resp, err := c.put(relativeUrl, "application/json", reqbody)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	body, err := c.handleResponse(resp)
-	if err != nil {
-		return nil, err
-	}
-
-	var m fission.Metadata
-	err = json.Unmarshal(body, &m)
-	if err != nil {
-		return nil, err
-	}
-	return &m, nil
-}
-
-func (c *Client) EnvironmentDelete(m *fission.Metadata) error {
-	relativeUrl := fmt.Sprintf("environments/%v", m.Name)
-	if len(m.Uid) > 0 {
-		relativeUrl += fmt.Sprintf("?uid=%v", m.Uid)
-	}
-	err := c.delete(relativeUrl)
-	return err
-}
-
-func (c *Client) EnvironmentList() ([]fission.Environment, error) {
-	resp, err := http.Get(c.url("environments"))
-	if err != nil {
-		return nil, err
-	}
-
-	body, err := c.handleResponse(resp)
-	if err != nil {
-		return nil, err
-	}
-
-	envs := make([]fission.Environment, 0)
-	err = json.Unmarshal(body, &envs)
-	if err != nil {
-		return nil, err
-	}
-
-	return envs, nil
-}
-
-func (c *Client) WatchCreate(w *fission.Watch) (*fission.Metadata, error) {
-	reqbody, err := json.Marshal(w)
-	if err != nil {
-		return nil, err
-	}
-
-	resp, err := http.Post(c.url("watches"), "application/json", bytes.NewReader(reqbody))
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	body, err := c.handleResponse(resp)
-	if err != nil {
-		return nil, err
-	}
-
-	var m fission.Metadata
-	err = json.Unmarshal(body, &m)
-	if err != nil {
-		return nil, err
-	}
-
-	return &m, nil
-}
-
-func (c *Client) WatchGet(m *fission.Metadata) (*fission.Watch, error) {
-	relativeUrl := fmt.Sprintf("watches/%v", m.Name)
-	if len(m.Uid) > 0 {
-		relativeUrl += fmt.Sprintf("?uid=%v", m.Uid)
-	}
-
-	resp, err := http.Get(c.url(relativeUrl))
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	body, err := c.handleResponse(resp)
-	if err != nil {
-		return nil, err
-	}
-
-	var w fission.Watch
-	err = json.Unmarshal(body, &w)
-	if err != nil {
-		return nil, err
-	}
-
-	return &w, nil
-}
-
-func (c *Client) WatchUpdate(w *fission.Watch) (*fission.Metadata, error) {
-	return nil, fission.MakeError(fission.ErrorNotImplmented,
-		"watch update not implemented")
-}
-
-func (c *Client) WatchDelete(m *fission.Metadata) error {
-	relativeUrl := fmt.Sprintf("watches/%v", m.Name)
-	if len(m.Uid) > 0 {
-		relativeUrl += fmt.Sprintf("?uid=%v", m.Uid)
-	}
-	err := c.delete(relativeUrl)
-	return err
-
-}
-
-func (c *Client) WatchList() ([]fission.Watch, error) {
-	resp, err := http.Get(c.url("watches"))
-	if err != nil {
-		return nil, err
-	}
-
-	body, err := c.handleResponse(resp)
-	if err != nil {
-		return nil, err
-	}
-
-	watches := make([]fission.Watch, 0)
-	err = json.Unmarshal(body, &watches)
-	if err != nil {
-		return nil, err
-	}
-
-	return watches, err
+	body, err := ioutil.ReadAll(resp.Body)
+	return body, err
 }

controller/client/environment.go

@@ -0,0 +1,132 @@
+/*
+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 client
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+
+	"k8s.io/client-go/1.5/pkg/api"
+
+	"github.com/fission/fission/tpr"
+)
+
+func (c *Client) EnvironmentCreate(env *tpr.Environment) (*api.ObjectMeta, error) {
+	reqbody, err := json.Marshal(env)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := http.Post(c.url("environments"), "application/json", bytes.NewReader(reqbody))
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := c.handleCreateResponse(resp)
+	if err != nil {
+		return nil, err
+	}
+
+	var m api.ObjectMeta
+	err = json.Unmarshal(body, &m)
+	if err != nil {
+		return nil, err
+	}
+
+	return &m, nil
+}
+
+func (c *Client) EnvironmentGet(m *api.ObjectMeta) (*tpr.Environment, error) {
+	relativeUrl := fmt.Sprintf("environments/%v", m.Name)
+	relativeUrl += fmt.Sprintf("?namespace=%v", m.Namespace)
+
+	resp, err := http.Get(c.url(relativeUrl))
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := c.handleResponse(resp)
+	if err != nil {
+		return nil, err
+	}
+
+	var env tpr.Environment
+	err = json.Unmarshal(body, &env)
+	if err != nil {
+		return nil, err
+	}
+
+	return &env, nil
+}
+
+func (c *Client) EnvironmentUpdate(env *tpr.Environment) (*api.ObjectMeta, error) {
+	reqbody, err := json.Marshal(env)
+	if err != nil {
+		return nil, err
+	}
+	relativeUrl := fmt.Sprintf("environments/%v", env.Metadata.Name)
+
+	resp, err := c.put(relativeUrl, "application/json", reqbody)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := c.handleResponse(resp)
+	if err != nil {
+		return nil, err
+	}
+
+	var m api.ObjectMeta
+	err = json.Unmarshal(body, &m)
+	if err != nil {
+		return nil, err
+	}
+	return &m, nil
+}
+
+func (c *Client) EnvironmentDelete(m *api.ObjectMeta) error {
+	relativeUrl := fmt.Sprintf("environments/%v", m.Name)
+	relativeUrl += fmt.Sprintf("?namespace=%v", m.Namespace)
+
+	return c.delete(relativeUrl)
+}
+
+func (c *Client) EnvironmentList() ([]tpr.Environment, error) {
+	resp, err := http.Get(c.url("environments"))
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := c.handleResponse(resp)
+	if err != nil {
+		return nil, err
+	}
+
+	envs := make([]tpr.Environment, 0)
+	err = json.Unmarshal(body, &envs)
+	if err != nil {
+		return nil, err
+	}
+
+	return envs, nil
+}

controller/client/function.go

@@ -0,0 +1,146 @@
+/*
+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 client
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+
+	"k8s.io/client-go/1.5/pkg/api"
+
+	"github.com/fission/fission/tpr"
+)
+
+func (c *Client) FunctionCreate(f *tpr.Function) (*api.ObjectMeta, error) {
+
+	reqbody, err := json.Marshal(f)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := http.Post(c.url("functions"), "application/json", bytes.NewReader(reqbody))
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := c.handleCreateResponse(resp)
+	if err != nil {
+		return nil, err
+	}
+
+	var m api.ObjectMeta
+	err = json.Unmarshal(body, &m)
+	if err != nil {
+		return nil, err
+	}
+
+	return &m, nil
+}
+
+func (c *Client) FunctionGet(m *api.ObjectMeta) (*tpr.Function, error) {
+	relativeUrl := fmt.Sprintf("functions/%v", m.Name)
+	relativeUrl += fmt.Sprintf("?namespace=%v", m.Namespace)
+
+	resp, err := http.Get(c.url(relativeUrl))
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := c.handleResponse(resp)
+	if err != nil {
+		return nil, err
+	}
+
+	var f tpr.Function
+	err = json.Unmarshal(body, &f)
+	if err != nil {
+		return nil, err
+	}
+
+	return &f, nil
+}
+
+func (c *Client) FunctionGetRawDeployment(m *api.ObjectMeta) ([]byte, error) {
+	relativeUrl := fmt.Sprintf("functions/%v", m.Name)
+	relativeUrl += fmt.Sprintf("?namespace=%v", m.Namespace)
+	relativeUrl += fmt.Sprintf("&deploymentraw=1")
+
+	resp, err := http.Get(c.url(relativeUrl))
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	return c.handleResponse(resp)
+}
+
+func (c *Client) FunctionUpdate(f *tpr.Function) (*api.ObjectMeta, error) {
+	reqbody, err := json.Marshal(f)
+	if err != nil {
+		return nil, err
+	}
+	relativeUrl := fmt.Sprintf("functions/%v", f.Metadata.Name)
+
+	resp, err := c.put(relativeUrl, "application/json", reqbody)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := c.handleResponse(resp)
+	if err != nil {
+		return nil, err
+	}
+
+	var m api.ObjectMeta
+	err = json.Unmarshal(body, &m)
+	if err != nil {
+		return nil, err
+	}
+	return &m, nil
+}
+
+func (c *Client) FunctionDelete(m *api.ObjectMeta) error {
+	relativeUrl := fmt.Sprintf("functions/%v", m.Name)
+	relativeUrl += fmt.Sprintf("?namespace=%v", m.Namespace)
+	return c.delete(relativeUrl)
+}
+
+func (c *Client) FunctionList() ([]tpr.Function, error) {
+	resp, err := http.Get(c.url("functions"))
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := c.handleResponse(resp)
+	if err != nil {
+		return nil, err
+	}
+
+	funcs := make([]tpr.Function, 0)
+	err = json.Unmarshal(body, &funcs)
+	if err != nil {
+		return nil, err
+	}
+
+	return funcs, nil
+}

controller/client/httptrigger.go

@@ -0,0 +1,131 @@
+/*
+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 client
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+
+	"k8s.io/client-go/1.5/pkg/api"
+
+	"github.com/fission/fission/tpr"
+)
+
+func (c *Client) HTTPTriggerCreate(t *tpr.Httptrigger) (*api.ObjectMeta, error) {
+	reqbody, err := json.Marshal(t)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := http.Post(c.url("triggers/http"), "application/json", bytes.NewReader(reqbody))
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := c.handleCreateResponse(resp)
+	if err != nil {
+		return nil, err
+	}
+
+	var m api.ObjectMeta
+	err = json.Unmarshal(body, &m)
+	if err != nil {
+		return nil, err
+	}
+
+	return &m, nil
+}
+
+func (c *Client) HTTPTriggerGet(m *api.ObjectMeta) (*tpr.Httptrigger, error) {
+	relativeUrl := fmt.Sprintf("triggers/http/%v", m.Name)
+	relativeUrl += fmt.Sprintf("?namespace=%v", m.Namespace)
+
+	resp, err := http.Get(c.url(relativeUrl))
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := c.handleResponse(resp)
+	if err != nil {
+		return nil, err
+	}
+
+	var t tpr.Httptrigger
+	err = json.Unmarshal(body, &t)
+	if err != nil {
+		return nil, err
+	}
+
+	return &t, nil
+}
+
+func (c *Client) HTTPTriggerUpdate(t *tpr.Httptrigger) (*api.ObjectMeta, error) {
+	reqbody, err := json.Marshal(t)
+	if err != nil {
+		return nil, err
+	}
+	relativeUrl := fmt.Sprintf("triggers/http/%v", t.Metadata.Name)
+
+	resp, err := c.put(relativeUrl, "application/json", reqbody)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := c.handleResponse(resp)
+	if err != nil {
+		return nil, err
+	}
+
+	var m api.ObjectMeta
+	err = json.Unmarshal(body, &m)
+	if err != nil {
+		return nil, err
+	}
+	return &m, nil
+}
+
+func (c *Client) HTTPTriggerDelete(m *api.ObjectMeta) error {
+	relativeUrl := fmt.Sprintf("triggers/http/%v", m.Name)
+	relativeUrl += fmt.Sprintf("?namespace=%v", m.Namespace)
+	return c.delete(relativeUrl)
+}
+
+func (c *Client) HTTPTriggerList() ([]tpr.Httptrigger, error) {
+	resp, err := http.Get(c.url("triggers/http"))
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := c.handleResponse(resp)
+	if err != nil {
+		return nil, err
+	}
+
+	triggers := make([]tpr.Httptrigger, 0)
+	err = json.Unmarshal(body, &triggers)
+	if err != nil {
+		return nil, err
+	}
+
+	return triggers, nil
+}

controller/client/kuberneteswatchtrigger.go

@@ -0,0 +1,111 @@
+/*
+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 client
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+
+	"k8s.io/client-go/1.5/pkg/api"
+
+	"github.com/fission/fission"
+	"github.com/fission/fission/tpr"
+)
+
+func (c *Client) WatchCreate(w *tpr.Kuberneteswatchtrigger) (*api.ObjectMeta, error) {
+	reqbody, err := json.Marshal(w)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := http.Post(c.url("watches"), "application/json", bytes.NewReader(reqbody))
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := c.handleCreateResponse(resp)
+	if err != nil {
+		return nil, err
+	}
+
+	var m api.ObjectMeta
+	err = json.Unmarshal(body, &m)
+	if err != nil {
+		return nil, err
+	}
+
+	return &m, nil
+}
+
+func (c *Client) WatchGet(m *api.ObjectMeta) (*tpr.Kuberneteswatchtrigger, error) {
+	relativeUrl := fmt.Sprintf("watches/%v", m.Name)
+	relativeUrl += fmt.Sprintf("?namespace=%v", m.Namespace)
+
+	resp, err := http.Get(c.url(relativeUrl))
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := c.handleResponse(resp)
+	if err != nil {
+		return nil, err
+	}
+
+	var w tpr.Kuberneteswatchtrigger
+	err = json.Unmarshal(body, &w)
+	if err != nil {
+		return nil, err
+	}
+
+	return &w, nil
+}
+
+func (c *Client) WatchUpdate(w *tpr.Kuberneteswatchtrigger) (*api.ObjectMeta, error) {
+	return nil, fission.MakeError(fission.ErrorNotImplmented,
+		"watch update not implemented")
+}
+
+func (c *Client) WatchDelete(m *api.ObjectMeta) error {
+	relativeUrl := fmt.Sprintf("watches/%v", m.Name)
+	relativeUrl += fmt.Sprintf("?namespace=%v", m.Namespace)
+	return c.delete(relativeUrl)
+}
+
+func (c *Client) WatchList() ([]tpr.Kuberneteswatchtrigger, error) {
+	resp, err := http.Get(c.url("watches"))
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := c.handleResponse(resp)
+	if err != nil {
+		return nil, err
+	}
+
+	watches := make([]tpr.Kuberneteswatchtrigger, 0)
+	err = json.Unmarshal(body, &watches)
+	if err != nil {
+		return nil, err
+	}
+
+	return watches, err
+}

controller/client/mqtrigger.go

@@ -0,0 +1,137 @@
+/*
+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 client
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+
+	"k8s.io/client-go/1.5/pkg/api"
+
+	"github.com/fission/fission/tpr"
+)
+
+func (c *Client) MessageQueueTriggerCreate(t *tpr.Messagequeuetrigger) (*api.ObjectMeta, error) {
+	reqbody, err := json.Marshal(t)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := http.Post(c.url("triggers/messagequeue"), "application/json", bytes.NewReader(reqbody))
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := c.handleCreateResponse(resp)
+	if err != nil {
+		return nil, err
+	}
+
+	var m api.ObjectMeta
+	err = json.Unmarshal(body, &m)
+	if err != nil {
+		return nil, err
+	}
+
+	return &m, nil
+}
+
+func (c *Client) MessageQueueTriggerGet(m *api.ObjectMeta) (*tpr.Messagequeuetrigger, error) {
+	relativeUrl := fmt.Sprintf("triggers/messagequeue/%v", m.Name)
+	relativeUrl += fmt.Sprintf("?namespace=%v", m.Namespace)
+
+	resp, err := http.Get(c.url(relativeUrl))
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := c.handleResponse(resp)
+	if err != nil {
+		return nil, err
+	}
+
+	var t tpr.Messagequeuetrigger
+	err = json.Unmarshal(body, &t)
+	if err != nil {
+		return nil, err
+	}
+
+	return &t, nil
+}
+
+func (c *Client) MessageQueueTriggerUpdate(mqTrigger *tpr.Messagequeuetrigger) (*api.ObjectMeta, error) {
+	reqbody, err := json.Marshal(mqTrigger)
+	if err != nil {
+		return nil, err
+	}
+	relativeUrl := fmt.Sprintf("triggers/messagequeue/%v", mqTrigger.Metadata.Name)
+
+	resp, err := c.put(relativeUrl, "application/json", reqbody)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := c.handleResponse(resp)
+	if err != nil {
+		return nil, err
+	}
+
+	var m api.ObjectMeta
+	err = json.Unmarshal(body, &m)
+	if err != nil {
+		return nil, err
+	}
+	return &m, nil
+}
+
+func (c *Client) MessageQueueTriggerDelete(m *api.ObjectMeta) error {
+	relativeUrl := fmt.Sprintf("triggers/messagequeue/%v", m.Name)
+	relativeUrl += fmt.Sprintf("?namespace=%v", m.Namespace)
+	return c.delete(relativeUrl)
+}
+
+func (c *Client) MessageQueueTriggerList(mqType string) ([]tpr.Messagequeuetrigger, error) {
+	relativeUrl := "triggers/messagequeue"
+	if len(mqType) > 0 {
+		// TODO remove this, replace with field selector
+		relativeUrl += fmt.Sprintf("?mqtype=%v", mqType)
+	}
+
+	resp, err := http.Get(c.url(relativeUrl))
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := c.handleResponse(resp)
+	if err != nil {
+		return nil, err
+	}
+
+	triggers := make([]tpr.Messagequeuetrigger, 0)
+	err = json.Unmarshal(body, &triggers)
+	if err != nil {
+		return nil, err
+	}
+
+	return triggers, nil
+}

controller/client/package.go

@@ -0,0 +1,132 @@
+/*
+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 client
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+
+	"k8s.io/client-go/1.5/pkg/api"
+
+	"github.com/fission/fission/tpr"
+)
+
+func (c *Client) PackageCreate(f *tpr.Package) (*api.ObjectMeta, error) {
+
+	reqbody, err := json.Marshal(f)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := http.Post(c.url("packages"), "application/json", bytes.NewReader(reqbody))
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := c.handleCreateResponse(resp)
+	if err != nil {
+		return nil, err
+	}
+
+	var m api.ObjectMeta
+	err = json.Unmarshal(body, &m)
+	if err != nil {
+		return nil, err
+	}
+
+	return &m, nil
+}
+
+func (c *Client) PackageGet(m *api.ObjectMeta) (*tpr.Package, error) {
+	relativeUrl := fmt.Sprintf("packages/%v", m.Name)
+	relativeUrl += fmt.Sprintf("?namespace=%v", m.Namespace)
+
+	resp, err := http.Get(c.url(relativeUrl))
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := c.handleResponse(resp)
+	if err != nil {
+		return nil, err
+	}
+
+	var f tpr.Package
+	err = json.Unmarshal(body, &f)
+	if err != nil {
+		return nil, err
+	}
+
+	return &f, nil
+}
+
+func (c *Client) PackageUpdate(f *tpr.Package) (*api.ObjectMeta, error) {
+	reqbody, err := json.Marshal(f)
+	if err != nil {
+		return nil, err
+	}
+	relativeUrl := fmt.Sprintf("packages/%v", f.Metadata.Name)
+
+	resp, err := c.put(relativeUrl, "application/json", reqbody)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := c.handleResponse(resp)
+	if err != nil {
+		return nil, err
+	}
+
+	var m api.ObjectMeta
+	err = json.Unmarshal(body, &m)
+	if err != nil {
+		return nil, err
+	}
+	return &m, nil
+}
+
+func (c *Client) PackageDelete(m *api.ObjectMeta) error {
+	relativeUrl := fmt.Sprintf("packages/%v", m.Name)
+	relativeUrl += fmt.Sprintf("?namespace=%v", m.Namespace)
+	return c.delete(relativeUrl)
+}
+
+func (c *Client) PackageList() ([]tpr.Package, error) {
+	resp, err := http.Get(c.url("packages"))
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := c.handleResponse(resp)
+	if err != nil {
+		return nil, err
+	}
+
+	funcs := make([]tpr.Package, 0)
+	err = json.Unmarshal(body, &funcs)
+	if err != nil {
+		return nil, err
+	}
+
+	return funcs, nil
+}

controller/client/timetrigger.go

@@ -0,0 +1,131 @@
+/*
+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 client
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+
+	"k8s.io/client-go/1.5/pkg/api"
+
+	"github.com/fission/fission/tpr"
+)
+
+func (c *Client) TimeTriggerCreate(t *tpr.Timetrigger) (*api.ObjectMeta, error) {
+	reqbody, err := json.Marshal(t)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := http.Post(c.url("triggers/time"), "application/json", bytes.NewReader(reqbody))
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := c.handleCreateResponse(resp)
+	if err != nil {
+		return nil, err
+	}
+
+	var m api.ObjectMeta
+	err = json.Unmarshal(body, &m)
+	if err != nil {
+		return nil, err
+	}
+
+	return &m, nil
+}
+
+func (c *Client) TimeTriggerGet(m *api.ObjectMeta) (*tpr.Timetrigger, error) {
+	relativeUrl := fmt.Sprintf("triggers/time/%v", m.Name)
+	relativeUrl += fmt.Sprintf("?namespace=%v", m.Namespace)
+
+	resp, err := http.Get(c.url(relativeUrl))
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := c.handleResponse(resp)
+	if err != nil {
+		return nil, err
+	}
+
+	var t tpr.Timetrigger
+	err = json.Unmarshal(body, &t)
+	if err != nil {
+		return nil, err
+	}
+
+	return &t, nil
+}
+
+func (c *Client) TimeTriggerUpdate(t *tpr.Timetrigger) (*api.ObjectMeta, error) {
+	reqbody, err := json.Marshal(t)
+	if err != nil {
+		return nil, err
+	}
+	relativeUrl := fmt.Sprintf("triggers/time/%v", t.Metadata.Name)
+
+	resp, err := c.put(relativeUrl, "application/json", reqbody)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := c.handleResponse(resp)
+	if err != nil {
+		return nil, err
+	}
+
+	var m api.ObjectMeta
+	err = json.Unmarshal(body, &m)
+	if err != nil {
+		return nil, err
+	}
+	return &m, nil
+}
+
+func (c *Client) TimeTriggerDelete(m *api.ObjectMeta) error {
+	relativeUrl := fmt.Sprintf("triggers/time/%v", m.Name)
+	relativeUrl += fmt.Sprintf("?namespace=%v", m.Namespace)
+	return c.delete(relativeUrl)
+}
+
+func (c *Client) TimeTriggerList() ([]tpr.Timetrigger, error) {
+	resp, err := http.Get(c.url("triggers/time"))
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := c.handleResponse(resp)
+	if err != nil {
+		return nil, err
+	}
+
+	triggers := make([]tpr.Timetrigger, 0)
+	err = json.Unmarshal(body, &triggers)
+	if err != nil {
+		return nil, err
+	}
+
+	return triggers, nil
+}

controller/controller.go

@@ -14,20 +14,30 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package fission
+package controller
 
-func (f Function) Key() string {
-	return f.Metadata.Name
-}
+import (
+	"log"
 
-func (e Environment) Key() string {
-	return e.Metadata.Name
-}
+	"github.com/fission/fission/tpr"
+)
 
-func (ht HTTPTrigger) Key() string {
-	return ht.Metadata.Name
-}
+func Start(port int) {
+	fc, kc, err := tpr.MakeFissionClient()
+	if err != nil {
+		log.Fatalf("Failed to connect to K8s API: %v", err)
+	}
 
-func (w Watch) Key() string {
-	return w.Metadata.Name
+	err = tpr.EnsureFissionTPRs(kc)
+	if err != nil {
+		log.Fatalf("Failed to create fission TPRs: %v", err)
+	}
+
+	fc.WaitForTPRs()
+
+	api, err := MakeAPI()
+	if err != nil {
+		log.Fatalf("Failed to start controller: %v", err)
+	}
+	api.Serve(port)
 }

controller/environmentApi.go

@@ -21,133 +21,140 @@ import (
 	"io/ioutil"
 	"net/http"
 
-	log "github.com/Sirupsen/logrus"
 	"github.com/gorilla/mux"
+	log "github.com/sirupsen/logrus"
+	"k8s.io/client-go/1.5/pkg/api"
 
 	"github.com/fission/fission"
+	"github.com/fission/fission/tpr"
 )
 
-func (api *API) EnvironmentApiList(w http.ResponseWriter, r *http.Request) {
-	envs, err := api.EnvironmentStore.List()
+func (a *API) EnvironmentApiList(w http.ResponseWriter, r *http.Request) {
+	envs, err := a.fissionClient.Environments(api.NamespaceAll).List(api.ListOptions{})
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
-	resp, err := json.Marshal(envs)
+	resp, err := json.Marshal(envs.Items)
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
-	api.respondWithSuccess(w, resp)
+	a.respondWithSuccess(w, resp)
 }
 
-func (api *API) EnvironmentApiCreate(w http.ResponseWriter, r *http.Request) {
+func (a *API) EnvironmentApiCreate(w http.ResponseWriter, r *http.Request) {
 	body, err := ioutil.ReadAll(r.Body)
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
+		return
 	}
-	defer r.Body.Close()
 
-	var env fission.Environment
+	var env tpr.Environment
 	err = json.Unmarshal(body, &env)
 	if err != nil {
 		log.Printf("Failed to unmarshal request body: [%v]", body)
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
-	uid, err := api.EnvironmentStore.Create(&env)
+	err = validateResourceName(env.Metadata.Name)
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
-	m := &fission.Metadata{Name: env.Metadata.Name, Uid: uid}
-	resp, err := json.Marshal(m)
+	enew, err := a.fissionClient.Environments(env.Metadata.Namespace).Create(&env)
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
-	api.respondWithSuccess(w, resp)
+	resp, err := json.Marshal(enew.Metadata)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+
+	w.WriteHeader(http.StatusCreated)
+	a.respondWithSuccess(w, resp)
 }
 
-func (api *API) EnvironmentApiGet(w http.ResponseWriter, r *http.Request) {
-	var m fission.Metadata
-
+func (a *API) EnvironmentApiGet(w http.ResponseWriter, r *http.Request) {
 	vars := mux.Vars(r)
-	m.Name = vars["environment"]
-	m.Uid = r.FormValue("uid") // empty if uid is absent
+	name := vars["environment"]
+	ns := vars["namespace"]
+	if len(ns) == 0 {
+		ns = api.NamespaceDefault
+	}
 
-	env, err := api.EnvironmentStore.Get(&m)
+	env, err := a.fissionClient.Environments(ns).Get(name)
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
 	resp, err := json.Marshal(env)
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
-	api.respondWithSuccess(w, resp)
+	a.respondWithSuccess(w, resp)
 }
 
-func (api *API) EnvironmentApiUpdate(w http.ResponseWriter, r *http.Request) {
+func (a *API) EnvironmentApiUpdate(w http.ResponseWriter, r *http.Request) {
 	vars := mux.Vars(r)
 	name := vars["environment"]
 
 	body, err := ioutil.ReadAll(r.Body)
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
+		return
 	}
 
-	var env fission.Environment
+	var env tpr.Environment
 	err = json.Unmarshal(body, &env)
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
 	if name != env.Metadata.Name {
 		err = fission.MakeError(fission.ErrorInvalidArgument, "Environment name doesn't match URL")
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
-	uid, err := api.EnvironmentStore.Update(&env)
+	enew, err := a.fissionClient.Environments(env.Metadata.Namespace).Update(&env)
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
-	m := &fission.Metadata{Name: env.Metadata.Name, Uid: uid}
-	resp, err := json.Marshal(m)
+	resp, err := json.Marshal(enew.Metadata)
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
-	api.respondWithSuccess(w, resp)
+	a.respondWithSuccess(w, resp)
 }
 
-func (api *API) EnvironmentApiDelete(w http.ResponseWriter, r *http.Request) {
+func (a *API) EnvironmentApiDelete(w http.ResponseWriter, r *http.Request) {
 	vars := mux.Vars(r)
-	var m fission.Metadata
-	m.Name = vars["environment"]
-
-	m.Uid = r.FormValue("uid") // empty if uid is absent
-	if len(m.Uid) == 0 {
-		log.WithFields(log.Fields{"httpTrigger": m.Name}).Info("Deleting all versions")
+	name := vars["environment"]
+	ns := vars["namespace"]
+	if len(ns) == 0 {
+		ns = api.NamespaceDefault
 	}
 
-	err := api.EnvironmentStore.Delete(m)
+	err := a.fissionClient.Environments(ns).Delete(name, &api.DeleteOptions{})
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
-	api.respondWithSuccess(w, []byte(""))
+	a.respondWithSuccess(w, []byte(""))
 }

controller/environmentStore.go

@@ -1,79 +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 controller
-
-import (
-	"github.com/satori/go.uuid"
-
-	"github.com/fission/fission"
-)
-
-type EnvironmentStore struct {
-	ResourceStore
-}
-
-func (es *EnvironmentStore) Create(e *fission.Environment) (string, error) {
-	e.Metadata.Uid = uuid.NewV4().String()
-	return e.Metadata.Uid, es.ResourceStore.create(e)
-}
-
-func (es *EnvironmentStore) Get(m *fission.Metadata) (*fission.Environment, error) {
-	var e fission.Environment
-	err := es.ResourceStore.read(m.Name, &e)
-	if err != nil {
-		return nil, err
-	}
-	return &e, nil
-}
-
-func (es *EnvironmentStore) Update(e *fission.Environment) (string, error) {
-	e.Metadata.Uid = uuid.NewV4().String()
-	return e.Metadata.Uid, es.ResourceStore.update(e)
-}
-
-func (es *EnvironmentStore) Delete(m fission.Metadata) error {
-	typeName, err := getTypeName(fission.Environment{})
-	if err != nil {
-		return err
-	}
-	return es.ResourceStore.delete(typeName, m.Name)
-}
-
-func (es *EnvironmentStore) List() ([]fission.Environment, error) {
-	typeName, err := getTypeName(fission.Environment{})
-	if err != nil {
-		return nil, err
-	}
-
-	bufs, err := es.ResourceStore.getAll(typeName)
-	if err != nil {
-		return nil, err
-	}
-
-	envs := make([]fission.Environment, 0, len(bufs))
-	js := JsonSerializer{}
-	for _, buf := range bufs {
-		var e fission.Environment
-		err = js.deserialize([]byte(buf), &e)
-		if err != nil {
-			return nil, err
-		}
-		envs = append(envs, e)
-	}
-
-	return envs, nil
-}

controller/fileStore.go

@@ -1,128 +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 controller
-
-import (
-	"io/ioutil"
-	"os"
-	"path"
-
-	log "github.com/Sirupsen/logrus"
-)
-
-type requestType int
-
-const (
-	READ requestType = iota
-	WRITE
-	DELETE
-)
-
-type (
-	FileStore struct {
-		root           string // abs path of root of filestore
-		requestChannel chan fileStoreRequest
-	}
-
-	fileStoreRequest struct {
-		requestType
-		fileName        string // relative path
-		fileContents    []byte
-		responseChannel chan fileStoreResponse
-	}
-
-	fileStoreResponse struct {
-		error
-		fileContents []byte
-	}
-)
-
-func MakeFileStore(path string) *FileStore {
-
-	// create directory if necessary
-	if _, err := os.Stat(path); err != nil {
-		if os.IsNotExist(err) {
-			err = os.MkdirAll(path, os.ModeDir|0700)
-			if err != nil {
-				log.Printf("Failed to create directory %v", path)
-				return nil
-			}
-			log.Printf("Created directory %v", path)
-		}
-	}
-
-	fileStore := &FileStore{
-		root:           path,
-		requestChannel: make(chan fileStoreRequest),
-	}
-	go fileStore.fileStoreService()
-	return fileStore
-}
-
-func (fs *FileStore) fileStoreService() {
-	for {
-		req := <-fs.requestChannel
-		response := &fileStoreResponse{}
-
-		log.WithFields(log.Fields{"file": req.fileName, "type": req.requestType}).Debug("fileStore request")
-		switch req.requestType {
-		case READ:
-			response.fileContents, response.error = ioutil.ReadFile(path.Join(fs.root, req.fileName))
-		case WRITE:
-			response.error = ioutil.WriteFile(path.Join(fs.root, req.fileName), req.fileContents, 0600)
-		case DELETE:
-			response.error = os.Remove(path.Join(fs.root, req.fileName))
-		default:
-			log.Panic("bad request")
-		}
-		req.responseChannel <- *response
-	}
-}
-
-func (fs *FileStore) read(fileName string) ([]byte, error) {
-	req := fileStoreRequest{
-		requestType:     READ,
-		fileName:        fileName,
-		responseChannel: make(chan fileStoreResponse),
-	}
-	fs.requestChannel <- req
-	response := <-req.responseChannel
-	return response.fileContents, response.error
-}
-
-func (fs *FileStore) write(fileName string, contents []byte) error {
-	req := fileStoreRequest{
-		requestType:     WRITE,
-		fileName:        fileName,
-		fileContents:    contents,
-		responseChannel: make(chan fileStoreResponse),
-	}
-	fs.requestChannel <- req
-	response := <-req.responseChannel
-	return response.error
-}
-
-func (fs *FileStore) delete(fileName string) error {
-	req := fileStoreRequest{
-		requestType:     DELETE,
-		fileName:        fileName,
-		responseChannel: make(chan fileStoreResponse),
-	}
-	fs.requestChannel <- req
-	response := <-req.responseChannel
-	return response.error
-}

controller/fileStore_test.go

@@ -1,63 +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 controller
-
-import (
-	"io/ioutil"
-	"log"
-	"os"
-	"testing"
-)
-
-func TestFileStore(t *testing.T) {
-	// tmp dir
-	dir, err := ioutil.TempDir("", "testFileStore")
-	if err != nil {
-		t.Fatalf("error creating temp dir: %v", err)
-	}
-	defer os.RemoveAll(dir)
-	log.Printf("temp dir at %v", dir)
-
-	// file store
-	fs := MakeFileStore(dir)
-
-	_, err = fs.read("nonexistent")
-	if err == nil {
-		t.Fatalf("expected an error")
-	}
-
-	path := "fileStoreTest"
-	contents := []byte("bar")
-	err = fs.write(path, contents)
-	if err != nil {
-		t.Fatalf("error: %v", err)
-	}
-
-	observedContents, err := fs.read(path)
-	if err != nil {
-		t.Fatalf("error: %v", err)
-	}
-
-	if string(observedContents) != string(contents) {
-		t.Fatalf("contents don't match")
-	}
-
-	err = fs.delete(path)
-	if err != nil {
-		t.Fatalf("error: %v", err)
-	}
-}

controller/functionApi.go

@@ -17,156 +17,174 @@ limitations under the License.
 package controller
 
 import (
+	"encoding/json"
 	"io/ioutil"
 	"net/http"
+	"net/http/httputil"
+	"net/url"
 
-	"encoding/json"
-	log "github.com/Sirupsen/logrus"
 	"github.com/gorilla/mux"
+	log "github.com/sirupsen/logrus"
+	"k8s.io/client-go/1.5/pkg/api"
 
-	"encoding/base64"
 	"github.com/fission/fission"
+	"github.com/fission/fission/tpr"
 )
 
-func (api *API) FunctionApiList(w http.ResponseWriter, r *http.Request) {
-	funcs, err := api.FunctionStore.List()
+func (a *API) FunctionApiList(w http.ResponseWriter, r *http.Request) {
+	funcs, err := a.fissionClient.Functions(api.NamespaceAll).List(api.ListOptions{})
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
-	resp, err := json.Marshal(funcs)
+	resp, err := json.Marshal(funcs.Items)
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
-	api.respondWithSuccess(w, resp)
+	a.respondWithSuccess(w, resp)
 }
 
-func (api *API) FunctionApiCreate(w http.ResponseWriter, r *http.Request) {
+func (a *API) FunctionApiCreate(w http.ResponseWriter, r *http.Request) {
 	body, err := ioutil.ReadAll(r.Body)
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
+		return
 	}
 
-	var f fission.Function
+	var f tpr.Function
 	err = json.Unmarshal(body, &f)
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
-	dec, err := base64.StdEncoding.DecodeString(f.Code)
+	err = validateResourceName(f.Metadata.Name)
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
-	f.Code = string(dec)
 
-	uid, err := api.FunctionStore.Create(&f)
+	fnew, err := a.fissionClient.Functions(f.Metadata.Namespace).Create(&f)
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
-	m := &fission.Metadata{Name: f.Name, Uid: uid}
-	resp, err := json.Marshal(m)
+	resp, err := json.Marshal(fnew.Metadata)
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
-	api.respondWithSuccess(w, resp)
+	w.WriteHeader(http.StatusCreated)
+	a.respondWithSuccess(w, resp)
 }
 
-func (api *API) FunctionApiGet(w http.ResponseWriter, r *http.Request) {
-	var m fission.Metadata
-
+func (a *API) FunctionApiGet(w http.ResponseWriter, r *http.Request) {
 	vars := mux.Vars(r)
-	m.Name = vars["function"]
-	m.Uid = r.FormValue("uid") // empty if uid is absent
-	raw := r.FormValue("raw")  // just the code
+	name := vars["function"]
+	ns := vars["namespace"]
+	if len(ns) == 0 {
+		ns = api.NamespaceDefault
+	}
 
-	f, err := api.FunctionStore.Get(&m)
+	f, err := a.fissionClient.Functions(ns).Get(name)
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
-	var resp []byte
-	if raw != "" {
-		resp = []byte(f.Code)
-	} else {
-		f.Code = base64.StdEncoding.EncodeToString([]byte(f.Code))
-		resp, err = json.Marshal(f)
-		if err != nil {
-			api.respondWithError(w, err)
-			return
-		}
+	resp, err := json.Marshal(f)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
 	}
-	api.respondWithSuccess(w, resp)
+	a.respondWithSuccess(w, resp)
 }
 
-func (api *API) FunctionApiUpdate(w http.ResponseWriter, r *http.Request) {
+func (a *API) FunctionApiUpdate(w http.ResponseWriter, r *http.Request) {
 	vars := mux.Vars(r)
-	funcName := vars["function"]
+	name := vars["function"]
 
 	body, err := ioutil.ReadAll(r.Body)
 	if err != nil {
-		api.respondWithError(w, err)
-	}
-
-	var f fission.Function
-	err = json.Unmarshal(body, &f)
-	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
-	if funcName != f.Metadata.Name {
+	var f tpr.Function
+	err = json.Unmarshal(body, &f)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+
+	if name != f.Metadata.Name {
 		err = fission.MakeError(fission.ErrorInvalidArgument, "Function name doesn't match URL")
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
-	dec, err := base64.StdEncoding.DecodeString(f.Code)
+	fnew, err := a.fissionClient.Functions(f.Metadata.Namespace).Update(&f)
 	if err != nil {
-		api.respondWithError(w, err)
-		return
-	}
-	f.Code = string(dec)
-
-	uid, err := api.FunctionStore.Update(&f)
-	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
-	m := &fission.Metadata{Name: f.Name, Uid: uid}
-	resp, err := json.Marshal(m)
+	resp, err := json.Marshal(fnew.Metadata)
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
-	api.respondWithSuccess(w, resp)
+	a.respondWithSuccess(w, resp)
 }
 
-func (api *API) FunctionApiDelete(w http.ResponseWriter, r *http.Request) {
+func (a *API) FunctionApiDelete(w http.ResponseWriter, r *http.Request) {
 	vars := mux.Vars(r)
-	var m fission.Metadata
-	m.Name = vars["function"]
-
-	m.Uid = r.FormValue("uid") // empty if uid is absent
-	if len(m.Uid) == 0 {
-		log.WithFields(log.Fields{"function": m.Name}).Info("Deleting all versions")
+	name := vars["function"]
+	ns := vars["namespace"]
+	if len(ns) == 0 {
+		ns = api.NamespaceDefault
 	}
 
-	err := api.FunctionStore.Delete(m)
+	err := a.fissionClient.Functions(ns).Delete(name, &api.DeleteOptions{})
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
-	api.respondWithSuccess(w, []byte(""))
+	a.respondWithSuccess(w, []byte(""))
+}
+
+// FunctionLogsApiPost establishes a proxy server to log database, and redirect
+// query command send from client to database then proxy back the db response.
+func (a *API) FunctionLogsApiPost(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	// get dbType from url
+	dbType := vars["dbType"]
+
+	// find correspond db http url
+	dbCnf := a.getLogDBConfig(dbType)
+
+	svcUrl, err := url.Parse(dbCnf.httpURL)
+	if err != nil {
+		log.Printf("Failed to establish proxy server for function logs: %v", err)
+	}
+	// set up proxy server director
+	director := func(req *http.Request) {
+		// only replace url Scheme and Host to remote influxDB
+		// and leave query string intact
+		req.URL.Scheme = svcUrl.Scheme
+		req.URL.Host = svcUrl.Host
+		req.URL.Path = svcUrl.Path
+		// set up http basic auth for database authentication
+		req.SetBasicAuth(dbCnf.username, dbCnf.password)
+	}
+	proxy := &httputil.ReverseProxy{
+		Director: director,
+	}
+	proxy.ServeHTTP(w, r)
 }

controller/functionStore.go

@@ -1,137 +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 controller
-
-import (
-	log "github.com/Sirupsen/logrus"
-
-	"github.com/fission/fission"
-)
-
-type FunctionStore struct {
-	ResourceStore
-}
-
-func (fs *FunctionStore) Create(f *fission.Function) (string, error) {
-	code := []byte(f.Code)
-	_, uid, err := fs.ResourceStore.writeFile(f.Key(), code)
-	if err != nil {
-		return "", err
-	}
-
-	f.Metadata.Uid = uid
-	f.Code = ""
-
-	err = fs.ResourceStore.create(f)
-	if err != nil {
-		fs.ResourceStore.deleteFile(f.Key(), uid) // ignore errors
-		return "", err
-	}
-	return f.Metadata.Uid, nil
-}
-
-func (fs *FunctionStore) Get(m *fission.Metadata) (*fission.Function, error) {
-	var f fission.Function
-	err := fs.ResourceStore.read(m.Name, &f)
-	if err != nil {
-		return nil, err
-	}
-
-	var code []byte
-	if len(m.Uid) > 0 {
-		log.WithFields(log.Fields{"Uid": m.Uid}).Info("fetching by uid")
-		code, err = fs.ResourceStore.readFile(m.Name, &m.Uid)
-		f.Metadata = *m
-	} else {
-		code, err = fs.ResourceStore.readFile(m.Name, nil)
-	}
-	if err != nil {
-		return nil, err
-	}
-
-	f.Code = string(code)
-	return &f, nil
-}
-
-func (fs *FunctionStore) Update(f *fission.Function) (string, error) {
-	code := []byte(f.Code)
-	_, uid, err := fs.ResourceStore.writeFile(f.Key(), code)
-	if err != nil {
-		return "", err
-	}
-
-	var fnew fission.Function
-	err = fs.ResourceStore.read(f.Metadata.Name, &fnew)
-	if err != nil {
-		fs.ResourceStore.deleteFile(f.Key(), uid) // ignore err
-		return "", err
-	}
-
-	fnew.Metadata.Uid = uid
-	fnew.Environment = f.Environment
-
-	err = fs.ResourceStore.update(fnew)
-	if err != nil {
-		fs.ResourceStore.deleteFile(f.Key(), uid) // ignore err
-		return "", err
-	}
-	return uid, err
-}
-
-func (fs *FunctionStore) Delete(m fission.Metadata) error {
-	if len(m.Uid) == 0 {
-		err := fs.ResourceStore.deleteAllFiles(m.Name)
-		if err != nil {
-			return err
-		}
-	} else {
-		err := fs.ResourceStore.deleteFile(m.Name, m.Uid)
-		if err != nil {
-			return err
-		}
-	}
-	typeName, err := getTypeName(fission.Function{})
-	if err != nil {
-		return err
-	}
-	return fs.ResourceStore.delete(typeName, m.Name)
-}
-
-func (fs *FunctionStore) List() ([]fission.Function, error) {
-	typeName, err := getTypeName(fission.Function{})
-	if err != nil {
-		return nil, err
-	}
-
-	bufs, err := fs.ResourceStore.getAll(typeName)
-	if err != nil {
-		return nil, err
-	}
-
-	js := JsonSerializer{}
-	functions := make([]fission.Function, 0, len(bufs))
-	for _, buf := range bufs {
-		var f fission.Function
-		err = js.deserialize([]byte(buf), &f)
-		if err != nil {
-			return nil, err
-		}
-		functions = append(functions, f)
-	}
-
-	return functions, nil
-}

controller/httpTriggerApi.go

@@ -18,134 +18,170 @@ package controller
 
 import (
 	"encoding/json"
+	"fmt"
 	"io/ioutil"
 	"net/http"
 
-	log "github.com/Sirupsen/logrus"
 	"github.com/gorilla/mux"
+	"k8s.io/client-go/1.5/pkg/api"
 
 	"github.com/fission/fission"
+	"github.com/fission/fission/tpr"
 )
 
-func (api *API) HTTPTriggerApiList(w http.ResponseWriter, r *http.Request) {
-	triggers, err := api.HTTPTriggerStore.List()
+func (a *API) HTTPTriggerApiList(w http.ResponseWriter, r *http.Request) {
+	triggers, err := a.fissionClient.Httptriggers(api.NamespaceAll).List(api.ListOptions{})
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
-	resp, err := json.Marshal(triggers)
+	resp, err := json.Marshal(triggers.Items)
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
-	api.respondWithSuccess(w, resp)
+	a.respondWithSuccess(w, resp)
 }
 
-func (api *API) HTTPTriggerApiCreate(w http.ResponseWriter, r *http.Request) {
+func (a *API) checkHttpTriggerDuplicates(t *tpr.Httptrigger) error {
+	triggers, err := a.fissionClient.Httptriggers(api.NamespaceAll).List(api.ListOptions{})
+	if err != nil {
+		return err
+	}
+	for _, ht := range triggers.Items {
+		if ht.Spec.RelativeURL == t.Spec.RelativeURL && ht.Spec.Method == t.Spec.Method {
+			return fission.MakeError(fission.ErrorNameExists,
+				fmt.Sprintf("HTTPTrigger with same URL & method already exists (%v)",
+					ht.Metadata.Name))
+		}
+	}
+	return nil
+}
+
+func (a *API) HTTPTriggerApiCreate(w http.ResponseWriter, r *http.Request) {
 	body, err := ioutil.ReadAll(r.Body)
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
+		return
 	}
 
-	var t fission.HTTPTrigger
+	var t tpr.Httptrigger
 	err = json.Unmarshal(body, &t)
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
-	uid, err := api.HTTPTriggerStore.Create(&t)
+	err = validateResourceName(t.Metadata.Name)
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
-	m := &fission.Metadata{Name: t.Metadata.Name, Uid: uid}
-	resp, err := json.Marshal(m)
+	// Ensure we don't have a duplicate HTTP route defined (same URL and method)
+	err = a.checkHttpTriggerDuplicates(&t)
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
-	api.respondWithSuccess(w, resp)
+	tnew, err := a.fissionClient.Httptriggers(t.Metadata.Namespace).Create(&t)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+
+	resp, err := json.Marshal(tnew.Metadata)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+
+	w.WriteHeader(http.StatusCreated)
+	a.respondWithSuccess(w, resp)
 }
 
-func (api *API) HTTPTriggerApiGet(w http.ResponseWriter, r *http.Request) {
-	var m fission.Metadata
-
+func (a *API) HTTPTriggerApiGet(w http.ResponseWriter, r *http.Request) {
 	vars := mux.Vars(r)
-	m.Name = vars["httpTrigger"]
-	m.Uid = r.FormValue("uid") // empty if uid is absent
+	name := vars["httpTrigger"]
+	ns := vars["namespace"]
+	if len(ns) == 0 {
+		ns = api.NamespaceDefault
+	}
 
-	t, err := api.HTTPTriggerStore.Get(&m)
+	t, err := a.fissionClient.Httptriggers(ns).Get(name)
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
 	resp, err := json.Marshal(t)
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
-	api.respondWithSuccess(w, resp)
+	a.respondWithSuccess(w, resp)
 }
 
-func (api *API) HTTPTriggerApiUpdate(w http.ResponseWriter, r *http.Request) {
+func (a *API) HTTPTriggerApiUpdate(w http.ResponseWriter, r *http.Request) {
 	vars := mux.Vars(r)
 	name := vars["httpTrigger"]
 
 	body, err := ioutil.ReadAll(r.Body)
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
+		return
 	}
 
-	var t fission.HTTPTrigger
+	var t tpr.Httptrigger
 	err = json.Unmarshal(body, &t)
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
 	if name != t.Metadata.Name {
 		err = fission.MakeError(fission.ErrorInvalidArgument, "HTTPTrigger name doesn't match URL")
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
-	uid, err := api.HTTPTriggerStore.Update(&t)
+	err = a.checkHttpTriggerDuplicates(&t)
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
-	m := &fission.Metadata{Name: t.Metadata.Name, Uid: uid}
-	resp, err := json.Marshal(m)
+	tnew, err := a.fissionClient.Httptriggers(t.Metadata.Namespace).Update(&t)
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
-	api.respondWithSuccess(w, resp)
+
+	resp, err := json.Marshal(tnew.Metadata)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+	a.respondWithSuccess(w, resp)
 }
 
-func (api *API) HTTPTriggerApiDelete(w http.ResponseWriter, r *http.Request) {
+func (a *API) HTTPTriggerApiDelete(w http.ResponseWriter, r *http.Request) {
 	vars := mux.Vars(r)
-	var m fission.Metadata
-	m.Name = vars["httpTrigger"]
-
-	m.Uid = r.FormValue("uid") // empty if uid is absent
-	if len(m.Uid) == 0 {
-		log.WithFields(log.Fields{"httpTrigger": m.Name}).Info("Deleting all versions")
+	name := vars["httpTrigger"]
+	ns := vars["namespace"]
+	if len(ns) == 0 {
+		ns = api.NamespaceDefault
 	}
 
-	err := api.HTTPTriggerStore.Delete(m)
+	err := a.fissionClient.Httptriggers(ns).Delete(name, &api.DeleteOptions{})
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
-	api.respondWithSuccess(w, []byte(""))
+	a.respondWithSuccess(w, []byte(""))
 }

controller/httpTriggerStore.go

@@ -1,79 +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 controller
-
-import (
-	"github.com/satori/go.uuid"
-
-	"github.com/fission/fission"
-)
-
-type HTTPTriggerStore struct {
-	ResourceStore
-}
-
-func (hts *HTTPTriggerStore) Create(ht *fission.HTTPTrigger) (string, error) {
-	ht.Metadata.Uid = uuid.NewV4().String()
-	return ht.Metadata.Uid, hts.ResourceStore.create(ht)
-}
-
-func (hts *HTTPTriggerStore) Get(m *fission.Metadata) (*fission.HTTPTrigger, error) {
-	var ht fission.HTTPTrigger
-	err := hts.ResourceStore.read(m.Name, &ht)
-	if err != nil {
-		return nil, err
-	}
-	return &ht, nil
-}
-
-func (hts *HTTPTriggerStore) Update(ht *fission.HTTPTrigger) (string, error) {
-	ht.Metadata.Uid = uuid.NewV4().String()
-	return ht.Metadata.Uid, hts.ResourceStore.update(ht)
-}
-
-func (hts *HTTPTriggerStore) Delete(m fission.Metadata) error {
-	typeName, err := getTypeName(fission.HTTPTrigger{})
-	if err != nil {
-		return err
-	}
-	return hts.ResourceStore.delete(typeName, m.Name)
-}
-
-func (hts *HTTPTriggerStore) List() ([]fission.HTTPTrigger, error) {
-	typeName, err := getTypeName(fission.HTTPTrigger{})
-	if err != nil {
-		return nil, err
-	}
-
-	bufs, err := hts.ResourceStore.getAll(typeName)
-	if err != nil {
-		return nil, err
-	}
-
-	triggers := make([]fission.HTTPTrigger, 0, len(bufs))
-	js := JsonSerializer{}
-	for _, buf := range bufs {
-		var ht fission.HTTPTrigger
-		err = js.deserialize([]byte(buf), &ht)
-		if err != nil {
-			return nil, err
-		}
-		triggers = append(triggers, ht)
-	}
-
-	return triggers, nil
-}

controller/mqTriggerApi.go

@@ -0,0 +1,153 @@
+/*
+Copyright 2017 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 controller
+
+import (
+	"encoding/json"
+	"io/ioutil"
+	"net/http"
+
+	"github.com/gorilla/mux"
+	"k8s.io/client-go/1.5/pkg/api"
+
+	"github.com/fission/fission"
+	"github.com/fission/fission/tpr"
+)
+
+func (a *API) MessageQueueTriggerApiList(w http.ResponseWriter, r *http.Request) {
+	//mqType := r.FormValue("mqtype") // ignored for now
+	triggers, err := a.fissionClient.Messagequeuetriggers(api.NamespaceAll).List(api.ListOptions{})
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+	resp, err := json.Marshal(triggers.Items)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+	a.respondWithSuccess(w, resp)
+}
+
+func (a *API) MessageQueueTriggerApiCreate(w http.ResponseWriter, r *http.Request) {
+	body, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+
+	var mqTrigger tpr.Messagequeuetrigger
+	err = json.Unmarshal(body, &mqTrigger)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+
+	err = validateResourceName(mqTrigger.Metadata.Name)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+
+	tnew, err := a.fissionClient.Messagequeuetriggers(mqTrigger.Metadata.Namespace).Create(&mqTrigger)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+
+	resp, err := json.Marshal(tnew.Metadata)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+	w.WriteHeader(http.StatusCreated)
+	a.respondWithSuccess(w, resp)
+}
+
+func (a *API) MessageQueueTriggerApiGet(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	name := vars["mqTrigger"]
+	ns := vars["namespace"]
+	if len(ns) == 0 {
+		ns = api.NamespaceDefault
+	}
+
+	mqTrigger, err := a.fissionClient.Messagequeuetriggers(ns).Get(name)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+	resp, err := json.Marshal(mqTrigger)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+	a.respondWithSuccess(w, resp)
+}
+
+func (a *API) MessageQueueTriggerApiUpdate(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	name := vars["mqTrigger"]
+
+	body, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+
+	var mqTrigger tpr.Messagequeuetrigger
+	err = json.Unmarshal(body, &mqTrigger)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+
+	if name != mqTrigger.Metadata.Name {
+		err = fission.MakeError(fission.ErrorInvalidArgument, "Message queue trigger name doesn't match URL")
+		a.respondWithError(w, err)
+		return
+	}
+
+	tnew, err := a.fissionClient.Messagequeuetriggers(mqTrigger.Metadata.Namespace).Update(&mqTrigger)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+
+	resp, err := json.Marshal(tnew.Metadata)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+	a.respondWithSuccess(w, resp)
+}
+
+func (a *API) MessageQueueTriggerApiDelete(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	name := vars["mqTrigger"]
+	ns := vars["namespace"]
+	if len(ns) == 0 {
+		ns = api.NamespaceDefault
+	}
+
+	err := a.fissionClient.Messagequeuetriggers(ns).Delete(name, &api.DeleteOptions{})
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+	a.respondWithSuccess(w, []byte(""))
+}

controller/packageApi.go

@@ -0,0 +1,170 @@
+/*
+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 controller
+
+import (
+	"encoding/json"
+	"io/ioutil"
+	"net/http"
+
+	"github.com/gorilla/mux"
+	"k8s.io/client-go/1.5/pkg/api"
+
+	"github.com/fission/fission"
+	"github.com/fission/fission/tpr"
+)
+
+func (a *API) PackageApiList(w http.ResponseWriter, r *http.Request) {
+	funcs, err := a.fissionClient.Packages(api.NamespaceAll).List(api.ListOptions{})
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+
+	resp, err := json.Marshal(funcs.Items)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+
+	a.respondWithSuccess(w, resp)
+}
+
+func (a *API) PackageApiCreate(w http.ResponseWriter, r *http.Request) {
+	body, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+
+	var f tpr.Package
+	err = json.Unmarshal(body, &f)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+
+	err = validateResourceName(f.Metadata.Name)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+
+	// Ensure size limits
+	if len(f.Spec.Literal) > 256*1024 {
+		err := fission.MakeError(fission.ErrorInvalidArgument, "Package literal larger than 256K")
+		a.respondWithError(w, err)
+		return
+	}
+
+	fnew, err := a.fissionClient.Packages(f.Metadata.Namespace).Create(&f)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+
+	resp, err := json.Marshal(fnew.Metadata)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+
+	w.WriteHeader(http.StatusCreated)
+	a.respondWithSuccess(w, resp)
+}
+
+func (a *API) PackageApiGet(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	name := vars["package"]
+	ns := vars["namespace"]
+	if len(ns) == 0 {
+		ns = api.NamespaceDefault
+	}
+	raw := r.FormValue("raw") // just the deployment pkg
+
+	f, err := a.fissionClient.Packages(ns).Get(name)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+
+	var resp []byte
+	if raw != "" {
+		resp = []byte(f.Spec.Literal)
+	} else {
+		resp, err = json.Marshal(f)
+		if err != nil {
+			a.respondWithError(w, err)
+			return
+		}
+	}
+	a.respondWithSuccess(w, resp)
+}
+
+func (a *API) PackageApiUpdate(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	name := vars["package"]
+
+	body, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+
+	var f tpr.Package
+	err = json.Unmarshal(body, &f)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+
+	if name != f.Metadata.Name {
+		err = fission.MakeError(fission.ErrorInvalidArgument, "Package name doesn't match URL")
+		a.respondWithError(w, err)
+		return
+	}
+
+	fnew, err := a.fissionClient.Packages(f.Metadata.Namespace).Update(&f)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+
+	resp, err := json.Marshal(fnew.Metadata)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+	a.respondWithSuccess(w, resp)
+}
+
+func (a *API) PackageApiDelete(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	name := vars["package"]
+	ns := vars["namespace"]
+	if len(ns) == 0 {
+		ns = api.NamespaceDefault
+	}
+
+	err := a.fissionClient.Packages(ns).Delete(name, &api.DeleteOptions{})
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+
+	a.respondWithSuccess(w, []byte(""))
+}

controller/resourceStore.go

@@ -1,254 +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 controller
-
-import (
-	"errors"
-	"reflect"
-	"time"
-
-	log "github.com/Sirupsen/logrus"
-	"github.com/coreos/etcd/client"
-	"github.com/satori/go.uuid"
-	"golang.org/x/net/context"
-)
-
-type (
-	ResourceStore struct {
-		*FileStore
-		client.KeysAPI
-		serializer
-	}
-)
-
-func MakeResourceStore(fs *FileStore, etcdUrls []string) (*ResourceStore, error) {
-	ks, err := getEtcdKeyAPI(etcdUrls)
-	if err != nil {
-		return nil, err
-	}
-	s := JsonSerializer{}
-	return &ResourceStore{FileStore: fs, KeysAPI: ks, serializer: s}, nil
-}
-
-func getEtcdKeyAPI(etcdUrls []string) (client.KeysAPI, error) {
-	cfg := client.Config{
-		Endpoints: etcdUrls,
-		Transport: client.DefaultTransport,
-		// set timeout per request to fail fast when the target endpoint is unavailable
-		HeaderTimeoutPerRequest: time.Second,
-	}
-	c, err := client.New(cfg)
-	if err != nil {
-		log.Printf("failed to connect to etcd: %v", err)
-		return nil, err
-	}
-	return client.NewKeysAPI(c), nil
-}
-
-func getTypeName(r resource) (string, error) {
-	typ := reflect.TypeOf(r)
-	if typ.Kind().String() == "ptr" {
-		typ = typ.Elem()
-	}
-	typName := typ.Name()
-	if len(typName) == 0 {
-		return "", errors.New("Failed to get type")
-	}
-	return typName, nil
-}
-
-func getKey(r resource) (string, error) {
-	typName, err := getTypeName(r)
-	if err != nil {
-		return "", err
-	}
-	rkey := r.Key()
-	return (typName + "/" + rkey), nil
-}
-
-func (rs *ResourceStore) create(r resource) error {
-	key, err := getKey(r)
-	if err != nil {
-		return err
-	}
-
-	serialized, err := rs.serializer.serialize(r)
-	if err != nil {
-		return err
-	}
-
-	_, err = rs.KeysAPI.Set(context.Background(), key, string(serialized),
-		&client.SetOptions{PrevExist: client.PrevNoExist})
-	return err
-}
-
-func (rs *ResourceStore) read(rkey string, res resource) error {
-	typName, err := getTypeName(res)
-	if err != nil {
-		return err
-	}
-	key := typName + "/" + rkey
-
-	resp, err := rs.KeysAPI.Get(context.Background(), key, nil)
-	if err != nil {
-		return err
-	}
-	return rs.serializer.deserialize([]byte(resp.Node.Value), res)
-}
-
-func (rs *ResourceStore) update(r resource) error {
-	key, err := getKey(r)
-	if err != nil {
-		return err
-	}
-
-	serialized, err := rs.serializer.serialize(r)
-	if err != nil {
-		return err
-	}
-
-	_, err = rs.KeysAPI.Set(context.Background(), key, string(serialized),
-		&client.SetOptions{PrevExist: client.PrevExist})
-	return err
-}
-
-func (rs *ResourceStore) delete(typename, rkey string) error {
-	key := typename + "/" + rkey
-	_, err := rs.KeysAPI.Delete(context.Background(), key, nil) // ignore response
-	return err
-}
-
-// getAll finds all entries under key.  If none or found or key
-// doesn't exist, returns an empty slice.
-func (rs *ResourceStore) getAll(key string) ([]string, error) {
-	resp, err := rs.KeysAPI.Get(context.Background(), key, &client.GetOptions{Recursive: true})
-	if err != nil {
-		if client.IsKeyNotFound(err) {
-			return []string{}, nil
-		}
-		return nil, err
-	}
-
-	res := make([]string, 0, len(resp.Node.Nodes))
-	for _, n := range resp.Node.Nodes {
-		res = append(res, n.Value)
-	}
-	return res, nil
-}
-
-func (rs *ResourceStore) writeFile(parentKey string, contents []byte) (string, string, error) {
-	uid := uuid.NewV4().String()
-
-	err := rs.FileStore.write(uid, contents)
-	if err != nil {
-		return "", "", err
-	}
-
-	parentKey = "file/" + parentKey
-	resp, err := rs.KeysAPI.CreateInOrder(context.Background(), parentKey, uid, nil)
-	if err != nil {
-		_ = rs.FileStore.delete(uid)
-		return "", "", err
-	}
-
-	return resp.Node.Key, uid, nil
-}
-
-func (rs *ResourceStore) readFile(key string, uid *string) ([]byte, error) {
-	key = "file/" + key
-	resp, err := rs.KeysAPI.Get(context.Background(), key, &client.GetOptions{Sort: true})
-	if err != nil {
-		return nil, err
-	}
-
-	if uid == nil {
-		// get latest
-		n := resp.Node.Nodes
-		uid = &n[len(n)-1].Value
-	} else {
-		// validate uid is in the list
-		found := false
-		for _, u := range resp.Node.Nodes {
-			if *uid == u.Value {
-				found = true
-				break
-			}
-		}
-		if !found {
-			return nil, errors.New("Invalid UID " + *uid)
-		}
-	}
-
-	contents, err := rs.FileStore.read(*uid)
-	return contents, err
-}
-
-func (rs *ResourceStore) deleteFile(key string, uid string) error {
-	key = "file/" + key
-	resp, err := rs.KeysAPI.Get(context.Background(), key, &client.GetOptions{Sort: true})
-	if err != nil {
-		return err
-	}
-
-	var node *client.Node
-	for _, u := range resp.Node.Nodes {
-		if u.Value == uid {
-			node = u
-		}
-	}
-	if node == nil {
-		log.WithFields(log.Fields{"key": key, "uid": uid}).Error("unreferenced file")
-		return errors.New("won't delete unreferenced file")
-	}
-
-	err = rs.FileStore.delete(node.Value)
-	if err != nil {
-		return err
-	}
-
-	_, err = rs.KeysAPI.Delete(context.Background(), node.Key, nil)
-	if err != nil {
-		return err
-	}
-
-	if len(resp.Node.Nodes) == 1 {
-		_, err = rs.KeysAPI.Delete(context.Background(), key, &client.DeleteOptions{Dir: true})
-		return err
-	}
-	return nil
-}
-
-func (rs *ResourceStore) deleteAllFiles(key string) error {
-	key = "file/" + key
-	resp, err := rs.KeysAPI.Get(context.Background(), key, &client.GetOptions{Sort: true})
-	if err != nil {
-		return err
-	}
-	for _, u := range resp.Node.Nodes {
-		err = rs.FileStore.delete(u.Value)
-		if err != nil {
-			return err
-		}
-
-		_, err = rs.KeysAPI.Delete(context.Background(), u.Key, nil)
-		if err != nil {
-			return err
-		}
-	}
-	_, err = rs.KeysAPI.Delete(context.Background(), key, &client.DeleteOptions{Dir: true})
-	return err
-}

controller/resourceStore_test.go

@@ -1,152 +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 controller
-
-import (
-	"io/ioutil"
-	"log"
-	"os"
-	"testing"
-
-	"github.com/coreos/etcd/client"
-	"golang.org/x/net/context"
-)
-
-type TestResource struct {
-	A string
-	B int
-}
-
-func (tr TestResource) Key() string {
-	return tr.A
-}
-
-func panicIf(err error) {
-	if err != nil {
-		log.Panicf("err: %v", err)
-	}
-}
-
-func assert(b bool, msg string) {
-	if !b {
-		log.Panic("assertion failed: " + msg)
-	}
-}
-
-func getTestResourceStore() (*FileStore, client.KeysAPI, *ResourceStore) {
-	// make a tmp dir
-	dir, err := ioutil.TempDir("", "testFileStore")
-	panicIf(err)
-	fs := MakeFileStore(dir)
-
-	rs, err := MakeResourceStore(fs, []string{"http://localhost:2379"})
-	panicIf(err)
-
-	return fs, rs.KeysAPI, rs
-}
-
-func TestResourceStore(t *testing.T) {
-	fs, ks, rs := getTestResourceStore()
-	defer os.RemoveAll(fs.root)
-
-	s := JsonSerializer{}
-
-	tr := TestResource{A: "hello", B: 1}
-
-	// Delete the key first, in case of a panic'd previous test run; ignore errors
-	_ = rs.delete("TestResource", tr.Key())
-	ks.Delete(context.Background(), "/TestResource", &client.DeleteOptions{Dir: true})
-
-	// Verify getAll for empty db
-	trs, err := rs.getAll("TestResource")
-	panicIf(err)
-	if len(trs) != 0 {
-		log.Fatalf("Expected zero length slice, got %v", trs)
-	}
-
-	// Create
-	err = rs.create(tr)
-	panicIf(err)
-	defer ks.Delete(context.Background(), "/TestResource", &client.DeleteOptions{Dir: true})
-	defer rs.delete("TestResource", tr.Key())
-
-	// Etcd key /TestResource/hello should exist
-	_, err = ks.Get(context.Background(), "TestResource/hello", nil)
-	panicIf(err)
-
-	// Read
-	tr1 := TestResource{}
-	err = rs.read(tr.Key(), &tr1)
-	panicIf(err)
-	assert(tr1 == tr, "retrieved value must equal created value")
-
-	// Update and Read
-	tr.B += 1
-	err = rs.update(tr)
-	panicIf(err)
-	err = rs.read(tr.Key(), &tr1)
-	panicIf(err)
-	assert(tr1 == tr, "retrieved value must equal updated value")
-
-	// Get list
-	results, err := rs.getAll("TestResource")
-	panicIf(err)
-	res := make([]TestResource, 0, 0)
-	for _, r := range results {
-		tmp := TestResource{}
-		err = s.deserialize([]byte(r), &tmp)
-		panicIf(err)
-		res = append(res, tmp)
-	}
-	assert(res[0] == tr, "value from retrieved list must equal updated value")
-
-	// file tests
-	fileKey := "ResourceStoreTest"
-	fileContents1 := []byte("hello")
-	fileContents2 := []byte("world")
-	key, uid1, err := rs.writeFile(fileKey, fileContents1)
-	panicIf(err)
-	defer rs.deleteFile(fileKey, uid1)
-	log.Printf("key = %v, uid = %v", key, uid1)
-
-	// read latest
-	contents, err := rs.readFile(fileKey, nil)
-	panicIf(err)
-	assert(string(contents) == string(fileContents1), "retrieved file contents must match written value")
-
-	// update-- same key new contents
-	_, uid2, err := rs.writeFile(fileKey, fileContents2)
-	panicIf(err)
-	defer rs.deleteFile(fileKey, uid2)
-
-	// read latest
-	contents, err = rs.readFile(fileKey, nil)
-	panicIf(err)
-	assert(string(contents) == string(fileContents2), "retrieved file contents must match updated value")
-
-	// read by uid
-	// 1
-	contents, err = rs.readFile(fileKey, &uid1)
-	panicIf(err)
-	assert(string(contents) == string(fileContents1), "retrieved file contents must match updated value")
-
-	// 2
-	contents, err = rs.readFile(fileKey, &uid2)
-	panicIf(err)
-	assert(string(contents) == string(fileContents2), "retrieved file contents must match updated value")
-
-}

controller/storagesvc.go

@@ -0,0 +1,38 @@
+/*
+Copyright 2017 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 controller
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+	"net/http/httputil"
+	"net/url"
+)
+
+func (api *API) StorageServiceProxy(w http.ResponseWriter, r *http.Request) {
+	u := api.storageServiceUrl + "/v1/archive"
+	ssUrl, err := url.Parse(u)
+	if err != nil {
+		msg := fmt.Sprintf("Error parsing url %v: %v", u, err)
+		log.Println(msg)
+		http.Error(w, msg, 500)
+		return
+	}
+	proxy := httputil.NewSingleHostReverseProxy(ssUrl)
+	proxy.ServeHTTP(w, r)
+}

controller/timeTriggerApi.go

@@ -0,0 +1,174 @@
+/*
+Copyright 2017 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 controller
+
+import (
+	"encoding/json"
+	"io/ioutil"
+	"net/http"
+
+	"github.com/gorilla/mux"
+	"github.com/robfig/cron"
+	"k8s.io/client-go/1.5/pkg/api"
+
+	"github.com/fission/fission"
+	"github.com/fission/fission/tpr"
+)
+
+func (a *API) TimeTriggerApiList(w http.ResponseWriter, r *http.Request) {
+	triggers, err := a.fissionClient.Timetriggers(api.NamespaceAll).List(api.ListOptions{})
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+
+	resp, err := json.Marshal(triggers.Items)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+
+	a.respondWithSuccess(w, resp)
+}
+
+func (a *API) TimeTriggerApiCreate(w http.ResponseWriter, r *http.Request) {
+	body, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+
+	var t tpr.Timetrigger
+	err = json.Unmarshal(body, &t)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+
+	err = validateResourceName(t.Metadata.Name)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+
+	// validate
+	_, err = cron.Parse(t.Spec.Cron)
+	if err != nil {
+		err = fission.MakeError(fission.ErrorInvalidArgument, "TimeTrigger cron spec is not valid")
+		a.respondWithError(w, err)
+		return
+	}
+
+	tnew, err := a.fissionClient.Timetriggers(t.Metadata.Namespace).Create(&t)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+
+	resp, err := json.Marshal(tnew.Metadata)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+
+	w.WriteHeader(http.StatusCreated)
+	a.respondWithSuccess(w, resp)
+}
+
+func (a *API) TimeTriggerApiGet(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	name := vars["timeTrigger"]
+	ns := vars["namespace"]
+	if len(ns) == 0 {
+		ns = api.NamespaceDefault
+	}
+
+	t, err := a.fissionClient.Timetriggers(ns).Get(name)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+
+	resp, err := json.Marshal(t)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+
+	a.respondWithSuccess(w, resp)
+}
+
+func (a *API) TimeTriggerApiUpdate(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	name := vars["timeTrigger"]
+
+	body, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+
+	var t tpr.Timetrigger
+	err = json.Unmarshal(body, &t)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+
+	if name != t.Metadata.Name {
+		err = fission.MakeError(fission.ErrorInvalidArgument, "TimeTrigger name doesn't match URL")
+		a.respondWithError(w, err)
+		return
+	}
+
+	_, err = cron.Parse(t.Spec.Cron)
+	if err != nil {
+		err = fission.MakeError(fission.ErrorInvalidArgument, "TimeTrigger cron spec is not valid")
+		a.respondWithError(w, err)
+		return
+	}
+
+	tnew, err := a.fissionClient.Timetriggers(t.Metadata.Namespace).Update(&t)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+
+	resp, err := json.Marshal(tnew.Metadata)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+	a.respondWithSuccess(w, resp)
+}
+
+func (a *API) TimeTriggerApiDelete(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	name := vars["timeTrigger"]
+	ns := vars["namespace"]
+	if len(ns) == 0 {
+		ns = api.NamespaceDefault
+	}
+
+	err := a.fissionClient.Timetriggers(ns).Delete(name, &api.DeleteOptions{})
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+
+	a.respondWithSuccess(w, []byte(""))
+}

controller/tpr.go

@@ -0,0 +1,40 @@
+/*
+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 controller
+
+import (
+	"errors"
+	"regexp"
+
+	"github.com/fission/fission/tpr"
+)
+
+func makeTPRBackedAPI() (*API, error) {
+	fissionClient, _, err := tpr.MakeFissionClient()
+	if err != nil {
+		return nil, err
+	}
+	return &API{fissionClient: fissionClient}, nil
+}
+
+func validateResourceName(name string) error {
+	re := regexp.MustCompile(`[a-z0-9]([-a-z0-9]*[a-z0-9])?`)
+	if len(re.FindString(name)) != len(name) {
+		return errors.New("Name must consist of lower case alphanumeric characters or '-', and must start and end with an alphanumeric character (e.g. 'my-name',  or '123-abc', regex used for validation is '[a-z0-9]([-a-z0-9]*[a-z0-9])?'")
+	}
+	return nil
+}

controller/watchApi.go

@@ -21,101 +21,108 @@ import (
 	"io/ioutil"
 	"net/http"
 
-	log "github.com/Sirupsen/logrus"
 	"github.com/gorilla/mux"
+	"k8s.io/client-go/1.5/pkg/api"
 
 	"github.com/fission/fission"
+	"github.com/fission/fission/tpr"
 )
 
-func (api *API) WatchApiList(w http.ResponseWriter, r *http.Request) {
-	watches, err := api.WatchStore.List()
+func (a *API) WatchApiList(w http.ResponseWriter, r *http.Request) {
+	watches, err := a.fissionClient.Kuberneteswatchtriggers(api.NamespaceAll).List(api.ListOptions{})
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
-	resp, err := json.Marshal(watches)
+	resp, err := json.Marshal(watches.Items)
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
-	api.respondWithSuccess(w, resp)
+	a.respondWithSuccess(w, resp)
 }
 
-func (api *API) WatchApiCreate(w http.ResponseWriter, r *http.Request) {
+func (a *API) WatchApiCreate(w http.ResponseWriter, r *http.Request) {
 	body, err := ioutil.ReadAll(r.Body)
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
+		return
 	}
 
-	var watch fission.Watch
+	var watch tpr.Kuberneteswatchtrigger
 	err = json.Unmarshal(body, &watch)
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
-	watch.Target = fission.UrlForFunction(&watch.Function)
-
-	uid, err := api.WatchStore.Create(&watch)
+	err = validateResourceName(watch.Metadata.Name)
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
-	m := &fission.Metadata{Name: watch.Metadata.Name, Uid: uid}
-	resp, err := json.Marshal(m)
+	// TODO check for duplicate watches
+
+	wnew, err := a.fissionClient.Kuberneteswatchtriggers(watch.Metadata.Namespace).Create(&watch)
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
-	api.respondWithSuccess(w, resp)
+	resp, err := json.Marshal(wnew.Metadata)
+	if err != nil {
+		a.respondWithError(w, err)
+		return
+	}
+
+	w.WriteHeader(http.StatusCreated)
+	a.respondWithSuccess(w, resp)
 }
 
-func (api *API) WatchApiGet(w http.ResponseWriter, r *http.Request) {
-	var m fission.Metadata
-
+func (a *API) WatchApiGet(w http.ResponseWriter, r *http.Request) {
 	vars := mux.Vars(r)
-	m.Name = vars["watch"]
-	m.Uid = r.FormValue("uid") // empty if uid is absent
+	name := vars["watch"]
+	ns := vars["namespace"]
+	if len(ns) == 0 {
+		ns = api.NamespaceDefault
+	}
 
-	watch, err := api.WatchStore.Get(&m)
+	watch, err := a.fissionClient.Kuberneteswatchtriggers(ns).Get(name)
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
 	resp, err := json.Marshal(watch)
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
-	api.respondWithSuccess(w, resp)
+	a.respondWithSuccess(w, resp)
 }
 
-func (api *API) WatchApiUpdate(w http.ResponseWriter, r *http.Request) {
-	api.respondWithError(w, fission.MakeError(fission.ErrorNotImplmented,
+func (a *API) WatchApiUpdate(w http.ResponseWriter, r *http.Request) {
+	a.respondWithError(w, fission.MakeError(fission.ErrorNotImplmented,
 		"Not implemented"))
 }
 
-func (api *API) WatchApiDelete(w http.ResponseWriter, r *http.Request) {
+func (a *API) WatchApiDelete(w http.ResponseWriter, r *http.Request) {
 	vars := mux.Vars(r)
-	var m fission.Metadata
-	m.Name = vars["watch"]
-
-	m.Uid = r.FormValue("uid") // empty if uid is absent
-	if len(m.Uid) == 0 {
-		log.WithFields(log.Fields{"watch": m.Name}).Info("Deleting all versions")
+	name := vars["watch"]
+	ns := vars["namespace"]
+	if len(ns) == 0 {
+		ns = api.NamespaceDefault
 	}
 
-	err := api.WatchStore.Delete(m)
+	err := a.fissionClient.Kuberneteswatchtriggers(ns).Delete(name, &api.DeleteOptions{})
 	if err != nil {
-		api.respondWithError(w, err)
+		a.respondWithError(w, err)
 		return
 	}
 
-	api.respondWithSuccess(w, []byte(""))
+	a.respondWithSuccess(w, []byte(""))
 }

controller/watchStore.go

@@ -1,79 +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 controller
-
-import (
-	"github.com/satori/go.uuid"
-
-	"github.com/fission/fission"
-)
-
-type WatchStore struct {
-	ResourceStore
-}
-
-func (ws *WatchStore) Create(w *fission.Watch) (string, error) {
-	w.Metadata.Uid = uuid.NewV4().String()
-	return w.Metadata.Uid, ws.ResourceStore.create(w)
-}
-
-func (ws *WatchStore) Get(m *fission.Metadata) (*fission.Watch, error) {
-	var w fission.Watch
-	err := ws.ResourceStore.read(m.Name, &w)
-	if err != nil {
-		return nil, err
-	}
-	return &w, err
-}
-
-func (ws *WatchStore) Update(w *fission.Watch) (string, error) {
-	w.Metadata.Uid = uuid.NewV4().String()
-	return w.Metadata.Uid, ws.ResourceStore.update(w)
-}
-
-func (ws *WatchStore) Delete(m fission.Metadata) error {
-	typeName, err := getTypeName(fission.Watch{})
-	if err != nil {
-		return err
-	}
-	return ws.ResourceStore.delete(typeName, m.Name)
-}
-
-func (ws *WatchStore) List() ([]fission.Watch, error) {
-	typeName, err := getTypeName(fission.Watch{})
-	if err != nil {
-		return nil, err
-	}
-
-	bufs, err := ws.ResourceStore.getAll(typeName)
-	if err != nil {
-		return nil, err
-	}
-
-	watches := make([]fission.Watch, 0, len(bufs))
-	js := JsonSerializer{}
-	for _, buf := range bufs {
-		var w fission.Watch
-		err = js.deserialize([]byte(buf), &w)
-		if err != nil {
-			return nil, err
-		}
-		watches = append(watches, w)
-	}
-
-	return watches, nil
-}

demos/guestbook/add.py

@@ -0,0 +1,16 @@
+#
+# Handles POST /guestbook -- adds item to guestbook 
+#
+
+from flask import request, redirect
+import redis
+
+# Connect to redis.
+redisConnection = redis.StrictRedis(host='redis.guestbook', port=6379, db=0)
+
+def main():
+    # Read the item from POST params, add it to redis, and redirect
+    # back to the list
+    item = request.form['text']
+    redisConnection.rpush('guestbook', item)
+    return redirect('/guestbook', code=303)

demos/guestbook/cleanup.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+
+kubectl delete ns guestbook
+
+fission fn delete --name guestbook-add
+fission fn delete --name guestbook-get
+
+fission route list|grep guestbook|cut -f1 -d' '|xargs -n1 fission route delete --name

demos/guestbook/get.py

@@ -0,0 +1,28 @@
+#
+# Handles GET /guestbook -- returns a list of items in the guestbook
+# with a form to add more.
+#
+
+from flask import current_app, escape
+import redis
+
+# Connect to redis.  This is run only when this file is loaded; as
+# long as the pod is alive, the connection is reused.
+redisConnection = redis.StrictRedis(host='redis.guestbook', port=6379, db=0)
+
+def main():
+    messages = redisConnection.lrange('guestbook', 0, -1)
+
+    items = [("<li>%s</li>" % escape(m.decode('utf-8'))) for m in messages]
+    ul = "<ul>%s</ul>" % "\n".join(items)
+    return """
+      <html><body style="font-family:sans-serif;font-size:2rem;padding:40px">
+          <h1>Guestbook</h1>      
+          <form action="/guestbook" method="POST">
+            <input type="text" name="text">
+            <button type="submit">Add</button>
+          </form>
+          <hr/>
+          %s
+      </body></html>
+      """ % ul

demos/guestbook/redis.yaml

@@ -0,0 +1,45 @@
+apiVersion: v1
+kind: Namespace
+metadata:
+  name: guestbook
+  labels:
+    name: guestbook
+
+---
+apiVersion: extensions/v1beta1
+kind: Deployment
+metadata:
+  labels:
+    run: redis
+  name: redis
+  namespace: guestbook
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      run: redis
+  template:
+    metadata:
+      labels:
+        run: redis
+    spec:
+      containers:
+      - image: redis
+        name: redis
+
+---
+apiVersion: v1
+kind: Service
+metadata:
+  labels:
+    run: redis
+  name: redis
+  namespace: guestbook
+spec:
+  selector:
+    run: redis
+  type: ClusterIP
+  ports:
+  - port: 6379
+    protocol: TCP
+    targetPort: 6379

demos/guestbook/run.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+DEMO_RUN_FAST=1
+ROOT_DIR=$(dirname $0)/..
+. $ROOT_DIR/util.sh
+
+desc "Deploy redis"
+run "kubectl create -f redis.yaml"
+
+desc "Ensure fission has a python environment"
+run "fission env create --name python --image fission/python-env"
+
+desc "Register fission functions"
+run "fission function create --name guestbook-get --env python --code get.py --url /guestbook --method GET"
+run "fission function create --name guestbook-add --env python --code add.py --url /guestbook --method POST"
+
+echo "http://$FISSION_ROUTER/guestbook"
+

demos/hello/cleanup.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+fission fn delete --name hello
+fission route delete --name $(fission route list|grep hello|cut -f1 -d' ')

demos/hello/hello.js

@@ -0,0 +1,7 @@
+
+module.exports = async function(context) {
+    return {
+        status: 200,
+        body: "Hello, world!\n"
+    };
+}

demos/hello/run.sh

@@ -0,0 +1,40 @@
+#!/bin/bash
+
+DEMO_RUN_FAST=1
+ROOT_DIR=$(dirname $0)/..
+. $ROOT_DIR/util.sh
+
+desc "Kubernetes cluster"
+run "kubectl get nodes"
+
+desc "Fission installed"
+run "kubectl --namespace fission get deployment"
+
+clear
+
+desc "Hello world function"
+run "cat hello.js"
+
+desc "Add NodeJS environment to fission"
+run "fission env create --name nodejs --image fission/node-env"
+
+desc "NodeJS environment pods"
+run "kubectl --namespace fission-function get pod -l environmentName=nodejs"
+
+desc "Upload a function to fission"
+run "fission function create --name hello --env nodejs --code hello.js"
+
+desc "Set up a route \(HTTP trigger\) for the function"
+run "fission route create --method GET --url /hello --function hello"
+
+sleep 2
+
+desc "Finally, run the function"
+run "time -p curl http://$FISSION_ROUTER/hello"
+
+desc "Run the function again"
+run "time -p curl http://$FISSION_ROUTER/hello"
+run "time -p curl http://$FISSION_ROUTER/hello"
+
+desc "The pod is now labeled by the function name"
+run "kubectl --namespace fission-function get pod -l functionName=hello"

demos/util.sh

@@ -0,0 +1,78 @@
+#!/bin/bash
+# Copyright 2016 The Kubernetes 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.
+
+readonly  reset=$(tput sgr0)
+readonly  green=$(tput bold; tput setaf 2)
+readonly yellow=$(tput bold; tput setaf 3)
+readonly   blue=$(tput bold; tput setaf 6)
+readonly timeout=$(if [ "$(uname)" == "Darwin" ]; then echo "1"; else echo "0.1"; fi) 
+
+function desc() {
+    maybe_first_prompt
+    echo "$blue# $@$reset"
+    prompt
+}
+
+function prompt() {
+    echo -n "$yellow\$ $reset"
+}
+
+started=""
+function maybe_first_prompt() {
+    if [ -z "$started" ]; then
+        prompt
+        started=true
+    fi
+}
+
+# After a `run` this variable will hold the stdout of the command that was run.
+# If the command was interactive, this will likely be garbage.
+#DEMO_RUN_STDOUT=""
+
+function run() {
+    maybe_first_prompt
+    rate=25
+    if [ -n "$DEMO_RUN_FAST" ]; then
+      rate=1000
+    fi
+    echo "$green$1$reset" | pv -qL $rate
+    if [ -n "$DEMO_RUN_FAST" ]; then
+      sleep 0.5
+    fi
+    $1
+    echo; echo -n ">"
+    read -s
+    echo -e "\b "
+#    OFILE="$(mktemp -t $(basename $0).XXXXXX)"
+#    script -q -t0 "$OFILE" $1 # [removed -e,-c options -soam]
+#    r=$?
+#    read -d '' -t "${timeout}" -n 10000 # clear stdin
+#    prompt
+#    if [ -z "$DEMO_AUTO_RUN" ]; then
+#      read -s
+#    fi
+#    DEMO_RUN_STDOUT="$(tail -n +2 $OFILE | sed 's/\r//g')"
+#    return $r
+}
+
+function relative() {
+    for arg; do
+        echo "$(realpath $(dirname $(which $0)))/$arg" | sed "s|$(realpath $(pwd))|.|"
+    done
+}
+
+SSH_NODE=$(kubectl get nodes | tail -1 | cut -f1 -d' ')
+
+#trap "echo" EXIT

environments/binary/Dockerfile

@@ -0,0 +1,10 @@
+FROM alpine:3.5
+
+RUN apk update
+RUN apk add coreutils binutils findutils grep
+
+COPY . /app
+WORKDIR /app
+
+EXPOSE 8888
+ENTRYPOINT ["./server"]

environments/binary/README.md

@@ -0,0 +1,50 @@
+# Binary Environment Examples
+
+The `binary` runtime is a go server that uses a subprocess to invoke executables or execute shell scripts.
+
+Use Cases
+- Execute bash scripts
+- Run executables of languages that have no dedicated environment yet.
+
+## Words of Caution
+The environment runs on an alpine image with some additional utilty commandline tools installed, such as 'grep'. 
+However, in case you want to make use of more ecsoteric commandline tools, you should add the relevant apk to the 
+Dockerfile and build a new binary environment. See 'Compiling' for instructions.
+
+When executing functions using binaries, **ensure that the executable is built for the right architecture**. 
+Using the default binary environment this means that the binary should be build for Linux.
+
+## Usage
+The interface to the executable used by this environment is somewhat similar to a [CGI interface](https://en.wikipedia.org/wiki/Common_Gateway_Interface).
+This means that any HTTP headers are converted to environment variables of the form "HTTP_<header-name>". For example these
+are some of frequently occurring headers:
+
+```
+# Request Metadata
+CONTENT_LENGTH
+REQUEST_URI
+REQUEST_METHOD
+
+# HTTP Headers
+HTTP_ACCEPT
+HTTP_USER-AGENT
+...
+```
+
+The body of HTTP piped over the STDIN to the executable. 
+All output that is provided to the server over the STDOUT will be transformed into the HTTP response.
+
+
+## Compiling
+In order to build the Dockerfile, the server needs to be compiled to the right architecture.
+
+```bash
+sh ./build.sh
+```
+
+Build the Dockerfile:
+```bash
+docker build --tag=${USER}/binary-env .
+```
+
+See the [README](../../examples/binary/README.md) in the binary examples directory for usage instructions.

environments/binary/build.sh

@@ -0,0 +1,4 @@
+#!/bin/sh
+
+GOOS=linux GOARCH=386 go build -o server .
+

environments/binary/env.go

@@ -0,0 +1,47 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Utility functions for working with environment variables
+type Env struct {
+	Vars []*EnvVar
+}
+
+type EnvVar struct {
+	Key string
+	Val string
+}
+
+func FromString(rawEnvVar string) *EnvVar {
+	parts := strings.SplitN(rawEnvVar, "=", 2)
+	return &EnvVar{parts[0], parts[1]}
+}
+
+func (ev *EnvVar) ToString() string {
+	return fmt.Sprintf("%s=%s", ev.Key, ev.Val)
+}
+
+func (e *Env) SetEnv(envVar *EnvVar) {
+	e.Vars = append(e.Vars, envVar)
+}
+
+func (e *Env) ToStringEnv() []string {
+	var result []string
+	for _, envVar := range e.Vars {
+		result = append(result, envVar.ToString())
+	}
+	return result
+}
+
+func NewEnv(stringEnv []string) *Env {
+	env := &Env{}
+	if stringEnv != nil {
+		for _, rawEnvVar := range stringEnv {
+			env.SetEnv(FromString(rawEnvVar))
+		}
+	}
+	return env
+}

environments/binary/server.go

@@ -0,0 +1,134 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+)
+
+const (
+	DEFAULT_CODE_PATH          = "/userfunc/user"
+	DEFAULT_INTERNAL_CODE_PATH = "/bin/userfunc"
+)
+
+var specialized bool
+
+type BinaryServer struct {
+	fetchedCodePath  string
+	internalCodePath string
+}
+
+func (bs *BinaryServer) SpecializeHandler(w http.ResponseWriter, r *http.Request) {
+	if specialized {
+		w.WriteHeader(400)
+		w.Write([]byte("Not a generic container"))
+		return
+	}
+
+	_, err := os.Stat(bs.fetchedCodePath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			w.WriteHeader(http.StatusNotFound)
+			w.Write([]byte(bs.fetchedCodePath + ": not found"))
+			return
+		} else {
+			panic(err)
+		}
+	}
+
+	// Future: Check if executable is correct architecture/executable.
+
+	// Copy the executable to ensure that file is executable and immutable.
+	userFunc, err := ioutil.ReadFile(bs.fetchedCodePath)
+	if err != nil {
+		w.WriteHeader(http.StatusInternalServerError)
+		w.Write([]byte("Failed to read executable."))
+		return
+	}
+	err = ioutil.WriteFile(bs.internalCodePath, userFunc, 0555)
+	if err != nil {
+		w.WriteHeader(http.StatusInternalServerError)
+		w.Write([]byte("Failed to write executable to target location."))
+		return
+	}
+
+	fmt.Println("Specializing ...")
+	specialized = true
+	fmt.Println("Done")
+}
+
+func (bs *BinaryServer) InvocationHandler(w http.ResponseWriter, r *http.Request) {
+	if !specialized {
+		w.WriteHeader(http.StatusInternalServerError)
+		w.Write([]byte("Generic container: no requests supported"))
+		return
+	}
+
+	// CGI-like passing of environment variables
+	execEnv := NewEnv(nil)
+	execEnv.SetEnv(&EnvVar{"REQUEST_METHOD", r.Method})
+	execEnv.SetEnv(&EnvVar{"REQUEST_URI", r.RequestURI})
+	execEnv.SetEnv(&EnvVar{"CONTENT_LENGTH", fmt.Sprintf("%d", r.ContentLength)})
+
+	for header, val := range r.Header {
+		execEnv.SetEnv(&EnvVar{fmt.Sprintf("HTTP_%s", strings.ToUpper(header)), val[0]})
+	}
+
+	// Future: could be improved by keeping subprocess open while environment is specialized
+	cmd := exec.Command(bs.internalCodePath)
+	cmd.Env = execEnv.ToStringEnv()
+
+	if r.ContentLength != 0 {
+		fmt.Println(r.ContentLength)
+		stdin, err := cmd.StdinPipe()
+		if err != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			w.Write([]byte(fmt.Sprintf("Failed to get STDIN pipe: %s", err)))
+			panic(err)
+		}
+		_, err = io.Copy(stdin, r.Body)
+		if err != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			w.Write([]byte(fmt.Sprintf("Failed to pipe input: %s", err)))
+		}
+		stdin.Close()
+	}
+
+	out, err := cmd.Output()
+	if err != nil {
+		w.WriteHeader(http.StatusInternalServerError)
+		w.Write([]byte(fmt.Sprintf("Function error: %s", err)))
+		return
+	}
+
+	w.WriteHeader(http.StatusOK)
+	w.Write(out)
+}
+
+func main() {
+	codePath := flag.String("c", DEFAULT_CODE_PATH, "Path to expected fetched executable.")
+	internalCodePath := flag.String("i", DEFAULT_INTERNAL_CODE_PATH, "Path to specialized executable.")
+	flag.Parse()
+	absInternalCodePath, err := filepath.Abs(*internalCodePath)
+	if err != nil {
+		panic(err)
+	}
+	fmt.Printf("Using fetched code path: %s\n", *codePath)
+	fmt.Printf("Using internal code path: %s\n", absInternalCodePath)
+
+	server := &BinaryServer{*codePath, absInternalCodePath}
+	http.HandleFunc("/", server.InvocationHandler)
+	http.HandleFunc("/specialize", server.SpecializeHandler)
+
+	fmt.Println("Listening on 8888 ...")
+	err = http.ListenAndServe(":8888", nil)
+	if err != nil {
+		panic(err)
+	}
+}

environments/dotnet/.gitignore

@@ -0,0 +1,6 @@
+bin/*
+obj/*
+out/*
+.vscode/*
+project.lock*
+TODO_dotnet

environments/dotnet/Dockerfile

@@ -0,0 +1,9 @@
+FROM microsoft/dotnet:1.1.0-runtime
+
+WORKDIR /fission-workdir
+COPY out .
+EXPOSE 8888
+
+ENTRYPOINT ["dotnet"]
+
+CMD ["fission-dotnet.dll"]

environments/dotnet/ExecutorModule.cs

@@ -0,0 +1,82 @@
+using Fission.DotNetCore.Compiler;
+using Fission.DotNetCore.Api;
+using System.Collections.Generic;
+using Nancy;
+using System.IO;
+using System;
+
+namespace Fission.DotNetCore
+{
+    public class ExecutorModule : NancyModule
+    {
+#if DEBUG
+        private const string CODE_PATH = "/tmp/func.cs";
+#else
+        private const string CODE_PATH = "/userfunc/user";
+#endif
+        private static Function _userFunc;
+        private static Logger _logger = new Logger();
+
+        public ExecutorModule()
+        {
+            Post("/specialize", args => Specialize());
+            Get("/", _ => Run());
+            Post("/", _ => Run());
+            Put("/", _ => Run());
+            Head("/", _ => Run());
+            Options("/", _ => Run());
+            Delete("/", _ => Run());
+        }
+
+        private object Specialize()
+        {
+            var errors = new List<string>();
+            if (File.Exists(CODE_PATH))
+            {
+                var code = File.ReadAllText(CODE_PATH);
+                _userFunc = FissionCompiler.Compile(code, out errors);
+                if (_userFunc == null)
+                {
+                    var errstr = string.Join(Environment.NewLine, errors);
+                    _logger.WriteError(errstr);
+                    var response = (Response)errstr;
+                    response.StatusCode = HttpStatusCode.InternalServerError;
+                    return response;
+
+                }
+                return null;
+            }
+            else
+            {
+                var errstr = $"Unable to locate code at '{CODE_PATH}'";
+                _logger.WriteError(errstr);
+                var response = (Response)errstr;
+                response.StatusCode = HttpStatusCode.InternalServerError;
+                return response;
+            }
+        }
+
+        private object Run()
+        {
+            if (_userFunc == null)
+            {
+                var response = (Response)"Generic container: no requests supported";
+                response.StatusCode = HttpStatusCode.InternalServerError;
+                return response;
+            }
+            
+            try
+            {
+                return _userFunc.Invoke(FissionContext.Build(Request, new Logger()));
+            }
+            catch (Exception e)
+            {
+                _logger.WriteError(e.ToString());
+                var response = (Response)e.Message;
+                response.StatusCode = HttpStatusCode.BadRequest;
+                return response;
+            }
+        }
+    }
+}
+

environments/dotnet/FissionCompiler.cs

@@ -0,0 +1,75 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.Loader;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Emit;
+
+namespace Fission.DotNetCore.Compiler
+{
+    //adapted from this article http://www.tugberkugurlu.com/archive/compiling-c-sharp-code-into-memory-and-executing-it-with-roslyn
+    class FissionCompiler
+    {
+        public static Function Compile(string code, out List<string> errors)
+        {
+            errors = new List<string>();
+
+            SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(code);
+
+            string assemblyName = Path.GetRandomFileName();
+
+            var coreDir = Directory.GetParent(typeof(Enumerable).GetTypeInfo().Assembly.Location);      
+            
+            List<MetadataReference> references = new List<MetadataReference>
+            {
+                MetadataReference.CreateFromFile(coreDir.FullName + Path.DirectorySeparatorChar + "mscorlib.dll"),
+                MetadataReference.CreateFromFile(typeof(object).GetTypeInfo().Assembly.Location),
+                MetadataReference.CreateFromFile(Assembly.GetEntryAssembly().Location),
+                MetadataReference.CreateFromFile(typeof(System.Runtime.Serialization.Json.DataContractJsonSerializer).GetTypeInfo().Assembly.Location)
+            };
+
+            foreach (var referencedAssembly in Assembly.GetEntryAssembly().GetReferencedAssemblies())
+            {
+                var assembly = Assembly.Load(referencedAssembly);
+                references.Add(MetadataReference.CreateFromFile(assembly.Location));
+            }
+
+            CSharpCompilation compilation = CSharpCompilation.Create(
+                assemblyName,
+                syntaxTrees: new[] { syntaxTree },
+                references: references,
+                options: new CSharpCompilationOptions(
+                    OutputKind.DynamicallyLinkedLibrary,
+                    optimizationLevel: OptimizationLevel.Release));
+
+            using (var ms = new MemoryStream())
+            {
+                EmitResult result = compilation.Emit(ms);
+
+                if (!result.Success)
+                {
+                    IEnumerable<Diagnostic> failures = result.Diagnostics.Where(diagnostic =>
+                        diagnostic.IsWarningAsError ||
+                        diagnostic.Severity == DiagnosticSeverity.Error).ToList();
+
+                    foreach (Diagnostic diagnostic in failures)
+                    {
+                        errors.Add($"{diagnostic.Id}: {diagnostic.GetMessage()}");
+                    }
+                }
+                else
+                {
+                    ms.Seek(0, SeekOrigin.Begin);
+
+                    Assembly assembly = AssemblyLoadContext.Default.LoadFromStream(ms);
+                    var type = assembly.GetType("FissionFunction");
+                    var info = type.GetMember("Execute").First() as MethodInfo;
+                    return new Function(assembly, type, info);
+                }
+            }
+            return null;
+        }
+    }
+}

environments/dotnet/FissionContext.cs

@@ -0,0 +1,114 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Security.Cryptography.X509Certificates;
+using System.Text;
+using Nancy;
+
+namespace Fission.DotNetCore.Api
+{
+    public class FissionContext
+    {
+        public FissionContext(Dictionary<string, object> args, Logger logger, FissionHttpRequest request)
+        {
+            if (args == null) throw new ArgumentNullException(nameof(args));
+            if (logger == null) throw new ArgumentNullException(nameof(logger));
+            if (request == null) throw new ArgumentNullException(nameof(request));
+            Arguments = args;
+            Logger = logger;
+            Request = request;
+        }
+
+        public Dictionary<string, object> Arguments { get; private set; }
+
+        public FissionHttpRequest Request { get; private set; }
+
+        public Logger Logger { get; private set; }
+
+        public static FissionContext Build(Request request, Logger logger)
+        {
+            return new FissionContext(((DynamicDictionary)request.Query).ToDictionary(),
+                                        logger,
+                                        new FissionHttpRequest(request));
+        }
+    }
+
+    public class Logger
+    {
+        public void Write(Severity severity, string format, params object[] args)
+        {
+            Console.WriteLine($"{DateTime.Now.ToString("MM/dd/yy H:mm:ss zzz")} {severity}: " + format, args);
+        }
+
+        public void WriteInfo(string format, params object[] args)
+        {
+            Write(Severity.Info, format, args);
+        }
+
+        public void WriteWarning(string format, params object[] args)
+        {
+            Write(Severity.Warning, format, args);
+        }
+
+        public void WriteError(string format, params object[] args)
+        {
+            Write(Severity.Error, format, args);
+        }
+
+        public void WriteCritical(string format, params object[] args)
+        {
+            Write(Severity.Critical, format, args);
+        }
+
+        public void WriteVerbose(string format, params object[] args)
+        {
+            Write(Severity.Verbose, format, args);
+        }
+    }
+
+    public enum Severity
+    {
+        Info,
+        Warning,
+        Error,
+        Critical,
+        Verbose
+    }
+
+    public class FissionHttpRequest
+    {
+        private readonly Request _request;
+        internal FissionHttpRequest(Request request)
+        {
+            if (request == null) throw new ArgumentNullException(nameof(request));
+            _request = request;
+        }
+
+        public Stream Body { get { return _request.Body; } }
+
+        public string BodyAsString()
+        {
+            int length = (int)_request.Body.Length;
+            byte[] data = new byte[length];
+            _request.Body.Read(data, 0, length);
+            return Encoding.UTF8.GetString(data);
+        }
+        
+        public Dictionary<string, IEnumerable<string>> Headers
+        {
+            get
+            {
+                var headers = new Dictionary<string, IEnumerable<string>>();
+                foreach (var kv in _request.Headers)
+                {
+                    headers.Add(kv.Key, kv.Value);
+                }
+                return headers;
+            }
+        }
+
+        public X509Certificate Certificate { get { return _request.ClientCertificate; } }
+        public string Url { get { return _request.Url.ToString(); } }
+        public string Method { get { return _request.Method; } }
+    }
+}

environments/dotnet/Function.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Reflection;
+using Fission.DotNetCore.Api;
+
+namespace Fission.DotNetCore.Compiler
+{
+    class Function
+    {
+        private readonly Assembly _assembly;
+        private readonly Type _type;
+        private readonly MethodInfo _info;
+
+        public Function(Assembly assembly, Type type, MethodInfo info)
+        {
+            if (info == null) throw new ArgumentNullException(nameof(info));
+            if (assembly == null) throw new ArgumentNullException(nameof(assembly));
+            if (type == null) throw new ArgumentNullException(nameof(type));
+            _assembly = assembly;
+            _type = type;
+            _info = info;
+        }
+
+        public object Invoke(FissionContext context)
+        {
+            return _info.Invoke(_assembly.CreateInstance(_type.FullName), new[] { context });
+        }
+    }
+}

environments/dotnet/Program.cs

@@ -0,0 +1,21 @@
+using System.IO;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Nancy.Owin;
+
+namespace Fission.DotNetCore
+{
+    public class Program
+    {
+        public static void Main(string[] args)
+        {
+            var host = new WebHostBuilder()
+               .UseContentRoot(Directory.GetCurrentDirectory())
+               .UseKestrel()
+               .UseUrls("http://*:8888")
+               .Configure(app => app.UseOwin(x => x.UseNancy()))
+               .Build();
+            host.Run();
+        }
+    }
+}

environments/dotnet/README.md

@@ -0,0 +1,306 @@
+# Fission: dotnet C# Environment
+
+This is a simple dotnet C# environment for Fission.
+
+It's a Docker image containing the dotnet 1.1.0 runtime. The image 
+uses Kestrel with Nancy to host the internal web server and uses 
+Roslyn to compile the uploaded code.
+
+The image supports compiling and running code with types defined in
+mscorlib and does not at present support other library references.
+One workaround for this would be to add the references to this project's
+project.json file and rebuild the container.
+
+The environment works via convention where you create a C# class
+called FissionFunction which has a  method named Execute taking a single
+parameter, a FissionContext object.
+
+The FissionContext object gives access to the arguments and other items 
+like logging. Please see FissionContext.cs for public API.
+
+Example of simplest possible class to be executed:
+
+```
+using System;
+using Fission.DotNetCore.Api;
+
+public class FissionFunction {
+    public string Execute(FissionContext context) {
+        return null;
+    }
+}
+```
+
+Please see examples below.
+
+## Rebuilding and pushing the image
+
+To rebuild the image you need either a computer with dotnet 1.1.0
+installed or else you will have to map the source directory into a
+container containing the dotnet 1.1.0 environment.
+
+### Locally installed Dotnet 1.1.0
+
+Simply move to the source directory in a terminal and run the ./build.sh script.
+
+The script will restore dependencies, compile a release build and
+and build the container. If you need to change the name of the container
+simply change it in the script.
+
+After the build finishes push the new image to a Docker registry using the 
+standard procedure.
+
+### Build in a container
+
+Move to the directory containing the source and start the Docker container
+with dotnet and mount the current directory to a build location:
+
+```
+docker run -it --rm -v $PWD:/build microsoft/dotnet
+```
+
+Move to the build directory inside the container and restore the packages:
+
+```
+cd /build 
+dotnet restore
+log  : Restoring packages for /source/project.json...
+log  : Installing System.Net.WebSockets 4.0.0.
+log  : Installing runtime.native.System.IO.Compression 4.1.0.
+...
+```
+
+Compile and publish a release build of the source to the 'out' folder:
+
+```
+dotnet publish -c Release -o out
+Publishing source for .NETCoreApp,Version
+...
+```
+Exit the build container and build the Docker container on the local host:
+
+```
+exit
+docker build -t USER/dotnet-env .
+``` 
+After the build finishes push the new image to a Docker registry using the 
+standard procedure.
+
+## Echo example
+
+### Setup fission environment
+First you need to setup the fission according to your cluster setup as 
+specified here: https://github.com/fission/fission
+
+
+### Create the class to run
+
+Secondly you need to create a file /tmp/func.cs containing the following code:
+
+```
+using System;
+using Fission.DotNetCore.Api;
+
+public class FissionFunction 
+{
+    public string Execute(FissionContext context){
+        context.Logger.WriteInfo("executing.. {0}", context.Arguments["text"]);
+        return (string)context.Arguments["text"];
+    }
+}
+``` 
+### Run the example
+
+Lastly to run the example:
+
+```
+$ fission env create --name dotnet --image fission/dotnet-env
+
+$ fission function create --name echo --env dotnet --code /tmp/func.cs
+
+$ fission route create --method GET --url /echo --function echo
+
+$ curl http://$FISSION_ROUTER/echo?text=hello%20world!
+  hello world
+```
+
+## Addition service example
+
+### Setup fission environment
+First you need to setup the fission according to your cluster setup as 
+specified here: https://github.com/fission/fission
+
+
+### Create the class to run
+
+Secondly you need to create a file /tmp/func.cs containing the following code:
+
+```
+using System;
+using Fission.DotNetCore.Api;
+
+public class FissionFunction 
+{
+    public string Execute(FissionContext context){
+        var x = Convert.ToInt32(context.Arguments["x"]);
+        var y = Convert.ToInt32(context.Arguments["y"]);
+        return (x+y).ToString();
+    }
+}
+``` 
+### Run the example
+
+Lastly to run the example:
+
+```
+$ fission env create --name dotnet --image fission/dotnet-env
+
+$ fission function create --name addition --env dotnet --code /tmp/func.cs
+
+$ fission route create --method GET --url /add --function addition
+
+$ curl "http://$FISSION_ROUTER/add?x=30&y=12"
+  42
+```
+
+## Accessing http request information example
+
+### Setup fission environment
+First you need to setup the fission according to your cluster setup as 
+specified here: https://github.com/fission/fission
+
+
+### Create the class to run
+
+Secondly you need to create a file /tmp/func.cs containing the following code:
+
+```
+using System;
+using Fission.DotNetCore.Api;
+
+public class FissionFunction
+{
+    public string Execute(FissionContext context){
+        var buffer = new System.Text.StringBuilder();
+        foreach(var header in context.Request.Headers){
+                buffer.AppendLine(header.Key);
+                foreach(var item in header.Value){
+                        buffer.AppendLine($"\t{item}");
+                }
+        }
+        buffer.AppendLine($"Url: {context.Request.Url}, method: {context.Request.Method}");
+        return buffer.ToString();
+    }
+}
+
+``` 
+### Run the example
+
+Lastly to run the example:
+
+```
+$ fission env create --name dotnet --image fission/dotnet-env
+
+$ fission function create --name httpinfo --env dotnet --code /tmp/func.cs
+
+$ fission route create --method GET --url /http_info --function httpinfo
+
+$ curl "http://$FISSION_ROUTER/http_info"
+Accept
+	*/*;q=1
+Host
+	fissionserver:8888
+User-Agent
+	curl/7.47.0
+Url: http://fissionserver:8888, method: GET
+
+```
+
+## Accessing http request body example
+
+### Setup fission environment
+First you need to setup the fission according to your cluster setup as 
+specified here: https://github.com/fission/fission
+
+
+### Create the class to run
+
+Secondly you need to create a file /tmp/func.cs containing the following code:
+
+```
+using System.IO;
+using System.Runtime.Serialization.Json;
+using Fission.DotNetCore.Api;
+
+public class FissionFunction
+{
+    public string Execute(FissionContext context)
+    {
+        var person = Person.Deserialize(context.Request.Body);
+        return $"Hello, my name is {person.Name} and I am {person.Age} years old.";
+    }
+}
+
+public class Person
+{
+    public string Name { get; set; }
+    public int Age { get; set; }
+
+    public static Person Deserialize(Stream json)
+    {
+        var serializer = new DataContractJsonSerializer(typeof(Person));
+        return (Person)serializer.ReadObject(json);
+    }
+}
+
+``` 
+### Run the example
+
+Lastly to run the example:
+
+```
+$ fission env create --name dotnet --image fission/dotnet-env
+
+$ fission function create --name httpbody --env dotnet --code /tmp/func.cs
+
+$ fission route create --method GET --url /http_body --function httpbody
+
+$ curl -XPOST "http://$FISSION_ROUTER/http_body" -d '{ "Name":"Arthur", "Age":42}'
+Hello, my name is Arthur and I am 42 years old.
+
+```
+
+
+## Developing/debugging the enviroment locally
+
+The easiest way to debug the environment is to open the directory in
+Visual Studio Code (VSCode) as that will setup debugger for you the
+first time.
+
+Remember to install the excellent extension 
+"C# for Visual Studio Code(powered by OmniSharp)" to get statement completion
+
+The class ExecutorModule contain preprocessor directive overriding where 
+the input code file should be found:
+
+```
+#if DEBUG
+        private const string CODE_PATH = "/tmp/func.cs";
+#else
+        private const string CODE_PATH = "/userfunc/user";
+#endif
+```
+
+So what you need to do is:
+1. Open the directory in VSCode. 
+This will prompt restore of packages and query is debugger setup is needed. Accept both prompts.
+2. Press F5 to start the web server. Set breakpoints etc..
+3. Add a code file containing valid C# at /tmp/func.cs 
+4. Specialize the service with curl via post
+```
+$ curl -XPOST http://localhost:8888/specialize
+```
+5. Call your function with curl
+```
+$ curl -XGET http://localhost:8888
+``` 

environments/dotnet/build.sh

@@ -0,0 +1,3 @@
+dotnet restore
+dotnet publish -c Release -o out
+docker build -t fission/dotnet-env .

environments/dotnet/project.json

@@ -0,0 +1,24 @@
+{
+    "version": "1.0.0-*",
+    "buildOptions": {
+        "emitEntryPoint": true,
+        "outputName": "fission-dotnet"
+    },
+    "frameworks": {
+        "netcoreapp1.0": {
+            "dependencies": {
+                "Microsoft.NETCore.App": {
+                    "version": "1.1.0",
+                    "type": "platform"
+                },
+                "Microsoft.AspNetCore.Server.Kestrel": "1.0.0",
+                "Microsoft.AspNetCore.Owin": "1.0.0",
+                "Nancy": "2.0.0-barneyrubble",
+                "Microsoft.CodeAnalysis.CSharp": "1.3.0-*",
+                "System.Runtime.Loader": "4.0.0-*",
+                "System.Runtime.Serialization.Json": "4.0.2"
+            },
+            "imports": "netstandard1.3"
+        }
+    }
+}

environments/fetcher/build.sh

@@ -1 +0,0 @@
-GOOS=linux GOARCH=386 go build -o fetcher .

environments/fetcher/client/client.go

@@ -0,0 +1,35 @@
+package client
+
+import (
+	"bytes"
+	"encoding/json"
+	"net/http"
+	//"time"
+
+	"github.com/fission/fission"
+	"github.com/fission/fission/environments/fetcher"
+	//"github.com/fission/fission/router"
+)
+
+func DoFetchRequest(fetcherUrl string, fr *fetcher.FetchRequest) error {
+	body, err := json.Marshal(fr)
+	if err != nil {
+		return err
+	}
+
+	// client := http.Client{
+	// 	Transport: router.MakeRetryingRoundTripper(10, 50*time.Millisecond),
+	// }
+
+	resp, err := http.Post(fetcherUrl, "application/json", bytes.NewReader(body))
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		return fission.MakeErrorFromHTTP(resp)
+	}
+
+	return nil
+}

environments/fetcher/cmd/build.sh

@@ -0,0 +1,2 @@
+#!/bin/sh
+CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o fetcher .

environments/fetcher/cmd/main.go

@@ -0,0 +1,26 @@
+package main
+
+import (
+	"log"
+	"net/http"
+	"os"
+
+	"github.com/fission/fission/environments/fetcher"
+)
+
+// Usage: fetcher <shared volume path>
+func main() {
+	dir := os.Args[1]
+	if _, err := os.Stat(dir); err != nil {
+		if os.IsNotExist(err) {
+			err = os.MkdirAll(dir, os.ModeDir|0700)
+			if err != nil {
+				log.Fatalf("Error creating directory: %v", err)
+			}
+		}
+	}
+	fetcher := fetcher.MakeFetcher(dir)
+	mux := http.NewServeMux()
+	mux.HandleFunc("/", fetcher.Handler)
+	http.ListenAndServe(":8000", mux)
+}

environments/fetcher/fetcher.go

@@ -1,34 +1,120 @@
-package main
+package fetcher
 
 import (
+	"crypto/sha256"
+	"encoding/hex"
 	"encoding/json"
+	"errors"
 	"fmt"
+	"io"
 	"io/ioutil"
 	"log"
 	"net/http"
 	"os"
 	"path/filepath"
+	"time"
+
+	"github.com/mholt/archiver"
+	"github.com/satori/go.uuid"
+	"k8s.io/client-go/1.5/kubernetes"
+	"k8s.io/client-go/1.5/pkg/api"
+
+	"github.com/fission/fission"
+	"github.com/fission/fission/tpr"
 )
 
-type FetchRequest struct {
-	Url      string `json:"url"`
-	Filename string `json:"filename"`
-}
+type (
+	FetchRequestType int
 
-type Fetcher struct {
-	sharedVolumePath string
-}
+	FetchRequest struct {
+		FetchType     FetchRequestType `json:"fetchType"`
+		Function      api.ObjectMeta   `json:"function"`
+		Url           string           `json:"url"`
+		StorageSvcUrl string           `json:"storagesvcurl"`
+		Filename      string           `json:"filename"`
+	}
+
+	Fetcher struct {
+		sharedVolumePath string
+		fissionClient    *tpr.FissionClient
+		kubeClient       *kubernetes.Clientset
+	}
+)
+
+const (
+	FETCH_SOURCE = iota
+	FETCH_DEPLOYMENT
+	FETCH_URL // remove this?
+)
 
 func MakeFetcher(sharedVolumePath string) *Fetcher {
-	return &Fetcher{sharedVolumePath: sharedVolumePath}
+	fissionClient, kubeClient, err := tpr.MakeFissionClient()
+	if err != nil {
+		return nil
+	}
+	return &Fetcher{
+		sharedVolumePath: sharedVolumePath,
+		fissionClient:    fissionClient,
+		kubeClient:       kubeClient,
+	}
 }
 
-func (fetcher *Fetcher) handler(w http.ResponseWriter, r *http.Request) {
+func downloadUrl(url string, localPath string) error {
+	resp, err := http.Get(url)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+
+	err = ioutil.WriteFile(localPath, body, 0600)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func verifyChecksum(path string, checksum *fission.Checksum) error {
+	if checksum.Type != fission.ChecksumTypeSHA256 {
+		return fission.MakeError(fission.ErrorInvalidArgument, "Unsupported checksum type")
+	}
+
+	f, err := os.Open(path)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	hasher := sha256.New()
+	_, err = io.Copy(hasher, f)
+	if err != nil {
+		return err
+	}
+
+	c := hex.EncodeToString(hasher.Sum(nil))
+	if c != checksum.Sum {
+		return fission.MakeError(fission.ErrorChecksumFail, "Checksum validation failed")
+	}
+	return nil
+}
+
+func (fetcher *Fetcher) Handler(w http.ResponseWriter, r *http.Request) {
 	if r.Method != "POST" {
-		http.Error(w, "", 404)
+		http.Error(w, "", 405)
 		return
 	}
 
+	startTime := time.Now()
+	defer func() {
+		elapsed := time.Now().Sub(startTime)
+		log.Printf("elapsed time in fetch request = %v", elapsed)
+	}()
+
 	// parse request
 	body, err := ioutil.ReadAll(r.Body)
 	if err != nil {
@@ -40,65 +126,123 @@ func (fetcher *Fetcher) handler(w http.ResponseWriter, r *http.Request) {
 	err = json.Unmarshal(body, &req)
 	if err != nil {
 		log.Printf("Error reading request body: %v", err)
+		http.Error(w, err.Error(), 400)
+		return
+	}
+	log.Printf("fetcher received request: %v", req)
+
+	tmpFile := req.Filename + ".tmp"
+	tmpPath := filepath.Join(fetcher.sharedVolumePath, tmpFile)
+
+	if req.FetchType == FETCH_URL {
+		// fetch the file and save it to the tmp path
+		err := downloadUrl(req.Url, tmpPath)
+		if err != nil {
+			e := fmt.Sprintf("Failed to download url %v: %v", req.Url, err)
+			log.Printf(e)
+			http.Error(w, e, 400)
+			return
+		}
+	} else {
+		// get function object
+		fn, err := fetcher.fissionClient.Functions(req.Function.Namespace).Get(req.Function.Name)
+		if err != nil {
+			e := fmt.Sprintf("Failed to get function: %v", err)
+			log.Printf(e)
+			http.Error(w, e, 500)
+			return
+		}
+
+		// get pkg
+		var pkg *tpr.Package
+		if req.FetchType == FETCH_SOURCE {
+			pkg, err = fetcher.fissionClient.Packages(fn.Spec.Source.PackageRef.Namespace).Get(fn.Spec.Source.PackageRef.Name)
+		} else if req.FetchType == FETCH_DEPLOYMENT {
+			pkg, err = fetcher.fissionClient.Packages(fn.Spec.Deployment.PackageRef.Namespace).Get(fn.Spec.Deployment.PackageRef.Name)
+		}
+		if err != nil {
+			e := fmt.Sprintf("Failed to get package: %v", err)
+			log.Printf(e)
+			http.Error(w, e, 500)
+			return
+		}
+
+		// get package data as literal or by url
+		if len(pkg.Spec.Literal) > 0 {
+			// write pkg.Literal into tmpPath
+			err = ioutil.WriteFile(tmpPath, pkg.Spec.Literal, 0600)
+			if err != nil {
+				e := fmt.Sprintf("Failed to write file %v: %v", tmpPath, err)
+				log.Printf(e)
+				http.Error(w, e, 500)
+				return
+			}
+		} else {
+			// download and verify
+
+			err = downloadUrl(pkg.Spec.URL, tmpPath)
+			if err != nil {
+				e := fmt.Sprintf("Failed to download url %v: %v", req.Url, err)
+				log.Printf(e)
+				http.Error(w, e, 400)
+				return
+			}
+
+			err = verifyChecksum(tmpPath, &pkg.Spec.Checksum)
+			if err != nil {
+				e := fmt.Sprintf("Failed to verify checksum: %v", err)
+				log.Printf(e)
+				http.Error(w, e, 400)
+				return
+			}
+		}
+
+	}
+
+	// check file type here, if the file is a zip file unarchive it.
+	if archiver.Zip.Match(tmpPath) {
+		// unarchive tmp file to a tmp unarchive path
+		tmpUnarchivePath := filepath.Join(fetcher.sharedVolumePath, uuid.NewV4().String())
+		err = fetcher.unarchive(tmpPath, tmpUnarchivePath)
+		if err != nil {
+			log.Println(err.Error())
+			http.Error(w, err.Error(), 500)
+			return
+		}
+		tmpPath = tmpUnarchivePath
+	}
+
+	// move tmp file to requested filename
+	err = fetcher.rename(tmpPath, filepath.Join(fetcher.sharedVolumePath, req.Filename))
+	if err != nil {
+		log.Println(err.Error())
 		http.Error(w, err.Error(), 500)
 		return
 	}
-	log.Printf("fetcher request: %v", req)
-
-	// fetch the file and save it to tmp path
-	resp, err := http.Get(req.Url)
-	if err != nil {
-		e := fmt.Sprintf("Failed to fetch from url: %v", err)
-		log.Printf(e)
-		http.Error(w, e, 400)
-		return
-	}
-	defer resp.Body.Close()
-	body, err = ioutil.ReadAll(resp.Body)
-	if err != nil {
-		e := fmt.Sprintf("Failed to read from url: %v", err)
-		log.Printf(e)
-		http.Error(w, e, 400)
-		return
-	}
-	tmpFile := req.Filename + ".tmp"
-	tmpPath := filepath.Join(fetcher.sharedVolumePath, tmpFile)
-	err = ioutil.WriteFile(tmpPath, body, 0600)
-	if err != nil {
-		e := fmt.Sprintf("Failed to write file: %v", err)
-		log.Printf(e)
-		http.Error(w, e, 500)
-		return
-	}
-
-	// TODO: add signature verification
-
-	// move tmp file to requested filename
-	err = os.Rename(tmpPath, filepath.Join(fetcher.sharedVolumePath, req.Filename))
-	if err != nil {
-		e := fmt.Sprintf("Failed to move file: %v", err)
-		log.Printf(e)
-		http.Error(w, e, 500)
-		return
-	}
 
+	log.Printf("Completed fetch request")
 	// all done
 	w.WriteHeader(http.StatusOK)
 }
 
-// Usage: fetcher <shared volume path>
-func main() {
-	dir := os.Args[1]
-	if _, err := os.Stat(dir); err != nil {
-		if os.IsNotExist(err) {
-			err = os.MkdirAll(dir, os.ModeDir|0700)
-			if err != nil {
-				log.Fatalf("Error creating directory: %v", err)
-			}
-		}
+func (fetcher *Fetcher) rename(src string, dst string) error {
+	err := os.Rename(src, dst)
+	if err != nil {
+		return errors.New(fmt.Sprintf("Failed to move file: %v", err))
 	}
-	fetcher := MakeFetcher(dir)
-	mux := http.NewServeMux()
-	mux.HandleFunc("/", fetcher.handler)
-	http.ListenAndServe(":8000", mux)
+	return nil
+}
+
+// archive is a function that zips directory into a zip file
+func (fetcher *Fetcher) archive(src string, dst string) error {
+	return archiver.Zip.Make(dst, []string{src})
+}
+
+// unarchive is a function that unzips a zip file to destination
+func (fetcher *Fetcher) unarchive(src string, dst string) error {
+	err := archiver.Zip.Open(src, dst)
+	if err != nil {
+		return errors.New(fmt.Sprintf("Failed to unzip file: %v", err))
+	}
+	return nil
 }

environments/go/Dockerfile

@@ -0,0 +1,14 @@
+FROM golang:1.8.1
+
+ENV GOPATH /usr
+ENV APP	   ${GOPATH}/src/github.com/fission/fission/environments/go
+
+ADD context	    ${APP}/context
+ADD server.go   ${APP}
+
+WORKDIR ${APP}
+RUN go get
+RUN go build -o /server server.go
+
+ENTRYPOINT ["/server"]
+EXPOSE 8888

environments/go/README.md

@@ -0,0 +1,40 @@
+# Fission: Go Environment
+
+This is the Go environment for Fission.
+
+It's a Docker image containing a Go 1.8 runtime, along with a dynamic loader.
+
+## Build this image
+
+```
+docker build -t USER/go-runtime . && docker push USER/go-runtime
+```
+
+Note that if you build the runtime, you must also build the go-builder
+image, to ensure that it's at the same version of go:
+
+```
+cd builder && docker build -t USER/go-builder . && docker push USER/go-builder
+```
+
+## Using the image in fission
+
+You can add this customized image to fission with "fission env
+create":
+
+```
+fission env create --name go-runtime --image USER/go-runtime
+```
+
+Or, if you already have an environment, you can update its image:
+
+```
+fission env update --name go-runtime --image USER/go-runtime   
+```
+
+After this, fission functions that have the env parameter set to the
+same environment name as this command will use this environment.
+
+## Creating functions to use this image
+
+See the [examples README](examples/go/README.md).

environments/go/builder/Dockerfile

@@ -0,0 +1,5 @@
+FROM golang:1.8.1
+
+ENV GOPATH /usr
+RUN go get github.com/fission/fission
+

environments/go/builder/go-function-build

@@ -0,0 +1,11 @@
+#!/bin/sh
+
+if [ $# -eq 0 ]
+then
+    echo "No arguments, building current dir"
+    filename='.'
+else
+    filename=$1
+fi
+
+docker run --rm -v $(pwd):/build -w /build fission/go-builder:1.8.1 go build -buildmode=plugin -o function.so $filename && echo "Compiled plugin: function.so. Use 'fission function create' to upload to fission."

environments/go/context/context.go

@@ -0,0 +1,10 @@
+package context
+
+type (
+	Context map[string]interface{}
+)
+
+func New() Context {
+	ctx := make(map[string]interface{})
+	return ctx
+}

environments/go/server.go

@@ -0,0 +1,83 @@
+package main
+
+import (
+	"fmt"
+	"net/http"
+	"os"
+	"plugin"
+
+	"github.com/fission/fission/environments/go/context"
+)
+
+const (
+	CODE_PATH = "/userfunc/user"
+)
+
+var userFunc http.HandlerFunc
+
+func loadPlugin() http.HandlerFunc {
+	p, err := plugin.Open(CODE_PATH)
+	if err != nil {
+		panic(err)
+	}
+	sym, err := p.Lookup("Handler")
+	if err != nil {
+		panic("Entry point not found")
+	}
+
+	switch h := sym.(type) {
+	case *http.Handler:
+		return (*h).ServeHTTP
+	case *http.HandlerFunc:
+		return *h
+	case func(http.ResponseWriter, *http.Request):
+		return h
+	case func(context.Context, http.ResponseWriter, *http.Request):
+		return func(w http.ResponseWriter, r *http.Request) {
+			c := context.New()
+			h(c, w, r)
+		}
+	default:
+		panic("Entry point not found: bad type")
+	}
+}
+
+func specializeHandler(w http.ResponseWriter, r *http.Request) {
+	if userFunc != nil {
+		w.WriteHeader(400)
+		w.Write([]byte("Not a generic container"))
+		return
+	}
+
+	_, err := os.Stat(CODE_PATH)
+	if err != nil {
+		if os.IsNotExist(err) {
+			w.WriteHeader(http.StatusNotFound)
+			w.Write([]byte(CODE_PATH + ": not found"))
+			return
+		} else {
+			panic(err)
+		}
+	}
+
+	fmt.Println("Specializing ...")
+	userFunc = loadPlugin()
+	fmt.Println("Done")
+}
+
+func main() {
+	http.HandleFunc("/specialize", specializeHandler)
+
+	// Generic route -- all http requests go to the user function.
+	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		if userFunc == nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			w.Write([]byte("Generic container: no requests supported"))
+			return
+		}
+		userFunc(w, r)
+	})
+
+	fmt.Println("Listening on 8888 ...")
+	http.ListenAndServe(":8888", nil)
+}