Nail/fission-src
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Split out the Package type into a first class Kubernetes resource (#295)

Browse Source 
Split out the Package type into a first class Kubernetes resource. Before this change, packages were implicitly tied to functions.

This wasn't ideal because:
 * Functions will need to share packages
 * A package storage system may be more generally useful than just
   functions (for example, for storing static assets)

This change does the following:
* Updates the fission and tpr types to add a new Package and PackageSpec.  It also creates a PackageRef type, and a FunctionPackageRef type. The PackageRef simply references a package, but the FunctionPackageRef includes the name of a function within the package. This allows us to share packages between different functions.
* Updates fetcher and other components for first-class packages
* Allows customization of fetcher image pull policy in the helm charts
This commit is contained in:
Soam Vasani
2017-08-25 13:40:45 -07:00
committed by GitHub
parent b19be5c0a3
commit 6f017cf400
20 changed files with 639 additions and 121 deletions
Download Patch File Download Diff File Expand all files Collapse all files
controller/api.go
+6
View File
@@ -106,6 +106,12 @@ func (api *API) Serve(port int) {
r.HandleFunc(`/v1/{rest:[a-zA-Z0-9=\-\/]+}`, api.ApiVersionMismatchHandler)
r.HandleFunc("/", api.HomeHandler)
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("/v2/functions", api.FunctionApiList).Methods("GET")
r.HandleFunc("/v2/functions", api.FunctionApiCreate).Methods("POST")
r.HandleFunc("/v2/functions/{function}", api.FunctionApiGet).Methods("GET")
controller/api_test.go
+6 -11
View File
@@ -27,7 +27,6 @@ import (
"k8s.io/client-go/1.5/pkg/api"
"bytes"
"github.com/fission/fission"
"github.com/fission/fission/controller/client"
"github.com/fission/fission/tpr"
@@ -83,8 +82,8 @@ func TestFunctionApi(t *testing.T) {
},
Spec: fission.FunctionSpec{
EnvironmentName: "nodejs",
Deployment: fission.Package{
Literal: []byte("code1"),
Deployment: fission.FunctionPackageRef{
FunctionName: "xxx",
},
},
}
@@ -94,22 +93,18 @@ func TestFunctionApi(t *testing.T) {
})
assertNotFoundFailure(err, "function")
m, err := g.client.FunctionCreate(testFunc)
_, err = g.client.FunctionCreate(testFunc)
panicIf(err)
_, err = g.client.FunctionCreate(testFunc)
assertNameReuseFailure(err, "function")
code, err := g.client.FunctionGetRawDeployment(m)
panicIf(err)
assert(bytes.Compare(code, testFunc.Spec.Deployment.Literal) == 0, "code from FunctionGetRawDeployment must match created function")
testFunc.Spec.Deployment.Literal = []byte("code2")
testFunc.Spec.Deployment.FunctionName = "yyy"
_, err = g.client.FunctionUpdate(testFunc)
panicIf(err)
testFunc.Metadata.Name = name2
m, err = g.client.FunctionCreate(testFunc)
_, err = g.client.FunctionCreate(testFunc)
panicIf(err)
funcs, err := g.client.FunctionList()
@@ -327,7 +322,7 @@ func TestMain(m *testing.M) {
go Start(8888)
time.Sleep(500 * time.Millisecond)
time.Sleep(time.Second)
g.client = client.MakeClient("http://localhost:8888")
resp, err := http.Get("http://localhost:8888/")
controller/client/function.go
-9
View File
@@ -24,20 +24,11 @@ import (
"k8s.io/client-go/1.5/pkg/api"
"github.com/fission/fission"
"github.com/fission/fission/tpr"
)
func (c *Client) FunctionCreate(f *tpr.Function) (*api.ObjectMeta, error) {
// ensure size limits
if len(f.Spec.Source.Literal) > 256*1024 {
return nil, fission.MakeError(fission.ErrorSizeLimitExceeded, "Source package literal larger than 256k")
}
if len(f.Spec.Deployment.Literal) > 256*1024 {
return nil, fission.MakeError(fission.ErrorSizeLimitExceeded, "Deployment package literal larger than 256k")
}
reqbody, err := json.Marshal(f)
if err != nil {
return nil, err
controller/client/package.go
+132
View File
@@ -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/functionApi.go
+4 -22
View File
@@ -67,18 +67,6 @@ func (a *API) FunctionApiCreate(w http.ResponseWriter, r *http.Request) {
return
}
// Ensure size limits
if len(f.Spec.Source.Literal) > 256*1024 {
err := fission.MakeError(fission.ErrorInvalidArgument, "Source package literal larger than 256K")
a.respondWithError(w, err)
return
}
if len(f.Spec.Deployment.Literal) > 256*1024 {
err := fission.MakeError(fission.ErrorInvalidArgument, "Deployment package literal larger than 256K")
a.respondWithError(w, err)
return
}
fnew, err := a.fissionClient.Functions(f.Metadata.Namespace).Create(&f)
if err != nil {
a.respondWithError(w, err)
@@ -102,7 +90,6 @@ func (a *API) FunctionApiGet(w http.ResponseWriter, r *http.Request) {
if len(ns) == 0 {
ns = api.NamespaceDefault
}
raw := r.FormValue("deploymentraw") // just the deployment pkg
f, err := a.fissionClient.Functions(ns).Get(name)
if err != nil {
@@ -110,15 +97,10 @@ func (a *API) FunctionApiGet(w http.ResponseWriter, r *http.Request) {
return
}
var resp []byte
if raw != "" {
resp = []byte(f.Spec.Deployment.Literal)
} else {
resp, err = json.Marshal(f)
if err != nil {
a.respondWithError(w, err)
return
}
resp, err := json.Marshal(f)
if err != nil {
a.respondWithError(w, err)
return
}
a.respondWithSuccess(w, resp)
}
controller/packageApi.go
+170
View File
@@ -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(""))
}