Executor abstraction (#384)

This change adds a layer of abstraction over poolmgr. Poolmgr is now just one of the ways to turn a function into a service; other implementations will be added. The executor abstraction is a uniform API over all these implementations.

* Executor layer added on top of pool manager

* Removed the external server for executor

* Minor changes to keep existing semantics as much possible

* Separating the executor vs. poolmgr backend functionality and associated data members

* Executor logic separated from Poolmgr backend completely, placeholder for new backend

* Changed references to poolmgr in tests

* Moved poolmgr to it's package, as a side effect moved Cache to its's package (was causing cyclical dependency) and had to make some data structures exposed outside package

* Rebased from master and changed references to tpr -> crd

* Executor layer added on top of pool manager

* Executor logic separated from Poolmgr backend completely, placeholder for new backend

* Changed podName to a generic objectReference in fscache (#391)

Changed podName to a generic objectReference in function service cache implementation.

* Moved poolmgr to it's package, as a side effect moved Cache to its's package (was causing cyclical dependency) and had to make some data structures exposed outside package

* Rebased from master and changed references to tpr -> crd

* Merged from master with latest changes

* Removed stale executor service & deployment from previous merge

* Addressed review comments, still testing some areas

router/functionHandler.go

@@ -28,18 +28,18 @@ import (
 	"github.com/gorilla/mux"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
-	poolmgrClient "github.com/fission/fission/poolmgr/client"
+	executorClient "github.com/fission/fission/executor/client"
 )
 
 type functionHandler struct {
 	fmap     *functionServiceMap
-	poolmgr  *poolmgrClient.Client
+	executor *executorClient.Client
 	function *metav1.ObjectMeta
 }
 
 func (fh *functionHandler) getServiceForFunction() (*url.URL, error) {
-	// call poolmgr, get a url for a function
-	svcName, err := fh.poolmgr.GetServiceForFunction(fh.function)
+	// call executor, get a url for a function
+	svcName, err := fh.executor.GetServiceForFunction(fh.function)
 	if err != nil {
 		return nil, err
 	}
@@ -83,10 +83,10 @@ func (rrt RetryingRoundTripper) RoundTrip(req *http.Request) (*http.Response, er
 }
 
 func (fh *functionHandler) tapService(serviceUrl *url.URL) {
-	if fh.poolmgr == nil {
+	if fh.executor == nil {
 		return
 	}
-	fh.poolmgr.TapService(serviceUrl)
+	fh.executor.TapService(serviceUrl)
 }
 
 func (fh *functionHandler) handler(responseWriter http.ResponseWriter, request *http.Request) {
@@ -121,7 +121,7 @@ func (fh *functionHandler) handler(responseWriter http.ResponseWriter, request *
 		fh.fmap.assign(fh.function, serviceUrl)
 	} else {
 		// if we're using our cache, asynchronously tell
-		// poolmgr we're using this service
+		// executor we're using this service
 		go fh.tapService(serviceUrl)
 	}
 

router/httpTriggers.go

@@ -30,14 +30,14 @@ import (
 
 	"github.com/fission/fission"
 	"github.com/fission/fission/crd"
-	poolmgrClient "github.com/fission/fission/poolmgr/client"
+	executorClient "github.com/fission/fission/executor/client"
 )
 
 type HTTPTriggerSet struct {
 	*functionServiceMap
 	*mutableRouter
 	fissionClient     *crd.FissionClient
-	poolmgr           *poolmgrClient.Client
+	executor          *executorClient.Client
 	resolver          *functionReferenceResolver
 	crdClient         *rest.RESTClient
 	triggers          []crd.HTTPTrigger
@@ -49,12 +49,12 @@ type HTTPTriggerSet struct {
 }
 
 func makeHTTPTriggerSet(fmap *functionServiceMap, fissionClient *crd.FissionClient,
-	poolmgr *poolmgrClient.Client, crdClient *rest.RESTClient) (*HTTPTriggerSet, k8sCache.Store, k8sCache.Store) {
+	executor *executorClient.Client, crdClient *rest.RESTClient) (*HTTPTriggerSet, k8sCache.Store, k8sCache.Store) {
 	httpTriggerSet := &HTTPTriggerSet{
 		functionServiceMap: fmap,
 		triggers:           []crd.HTTPTrigger{},
 		fissionClient:      fissionClient,
-		poolmgr:            poolmgr,
+		executor:           executor,
 		crdClient:          crdClient,
 	}
 	var tStore, fnStore k8sCache.Store
@@ -114,7 +114,7 @@ func (ts *HTTPTriggerSet) getRouter() *mux.Router {
 		fh := &functionHandler{
 			fmap:     ts.functionServiceMap,
 			function: rr.functionMetadata,
-			poolmgr:  ts.poolmgr,
+			executor: ts.executor,
 		}
 		muxRouter.HandleFunc(trigger.Spec.RelativeURL, fh.handler).Methods(trigger.Spec.Method)
 		if trigger.Spec.RelativeURL == "/" && trigger.Spec.Method == "GET" {
@@ -139,7 +139,7 @@ func (ts *HTTPTriggerSet) getRouter() *mux.Router {
 		fh := &functionHandler{
 			fmap:     ts.functionServiceMap,
 			function: &m,
-			poolmgr:  ts.poolmgr,
+			executor: ts.executor,
 		}
 		muxRouter.HandleFunc(fission.UrlForFunction(function.Metadata.Name), fh.handler)
 	}

router/router.go

@@ -51,7 +51,7 @@ import (
 	"github.com/gorilla/mux"
 
 	"github.com/fission/fission/crd"
-	poolmgrClient "github.com/fission/fission/poolmgr/client"
+	executorClient "github.com/fission/fission/executor/client"
 )
 
 // request url ---[mux]---> Function(name,uid) ----[fmap]----> k8s service url
@@ -71,17 +71,20 @@ func serve(ctx context.Context, port int, httpTriggerSet *HTTPTriggerSet, resolv
 	http.ListenAndServe(url, handlers.LoggingHandler(os.Stdout, mr))
 }
 
-func Start(port int, poolmgrUrl string) {
+func Start(port int, executorUrl string) {
 	fmap := makeFunctionServiceMap(time.Minute)
 
 	fissionClient, _, _, err := crd.MakeFissionClient()
 	if err != nil {
 		log.Fatalf("Error connecting to kubernetes API: %v", err)
 	}
+
 	restClient := fissionClient.GetCrdClient()
-	poolmgr := poolmgrClient.MakeClient(poolmgrUrl)
-	triggers, _, fnStore := makeHTTPTriggerSet(fmap, fissionClient, poolmgr, restClient)
+
+	executor := executorClient.MakeClient(executorUrl)
+	triggers, _, fnStore := makeHTTPTriggerSet(fmap, fissionClient, executor, restClient)
 	resolver := makeFunctionReferenceResolver(fnStore)
+
 	log.Printf("Starting router at port %v\n", port)
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()