commands/up/local; pkg/ansible; Add support for up local to Ansible Operator (#569)

This PR includes a bump in `controller-runtime` to `0.1.4`. Without it I was seeing an error:
```
2018/10/03 15:00:26 no kind "MemcachedList" is registered for version "cache.example.com/v1alpha1"
```

Author: dymurray

Gopkg.lock

@@ -28,4 +28,4 @@
 
 [[constraint]]
   name = "sigs.k8s.io/controller-runtime"
-  version = "v0.1.3"
+  version = "v0.1.4"

Gopkg.toml

@@ -29,8 +29,17 @@ import (
 	yaml "gopkg.in/yaml.v2"
 )
 
-const configYaml = "./config/config.yaml"
-const tmpDockerfile = "./tmp/build/Dockerfile"
+type OperatorType int
+
+const (
+	configYaml    = "./config/config.yaml"
+	gopkgToml     = "./Gopkg.toml"
+	tmpDockerfile = "./tmp/build/Dockerfile"
+)
+const (
+	OperatorTypeGo OperatorType = iota
+	OperatorTypeAnsible
+)
 
 // MustInProjectRoot checks if the current dir is the project root.
 func MustInProjectRoot() {
@@ -74,3 +83,15 @@ func GetCurrPkg() string {
 	currPkg := strings.Replace(wd, goSrc+string(filepath.Separator), "", 1)
 	return currPkg
 }
+
+// GetOperatorType returns type of operator is in cwd
+// This function should be called after verifying the user is in project root
+// e.g: "go", "ansible"
+func GetOperatorType() OperatorType {
+	// Assuming that if Gopkg.toml exists then this is a Go operator
+	_, err := os.Stat(gopkgToml)
+	if err != nil && os.IsNotExist(err) {
+		return OperatorTypeAnsible
+	}
+	return OperatorTypeGo
+}

commands/operator-sdk/cmd/cmdutil/util.go

@@ -16,19 +16,26 @@ package up
 
 import (
 	"fmt"
+	"log"
 	"os"
 	"os/exec"
 	"os/signal"
 	"os/user"
 	"path/filepath"
+	"runtime"
 	"strings"
 	"syscall"
 
 	"github.com/operator-framework/operator-sdk/commands/operator-sdk/cmd/cmdutil"
 	cmdError "github.com/operator-framework/operator-sdk/commands/operator-sdk/error"
+	ansibleOperator "github.com/operator-framework/operator-sdk/pkg/ansible/operator"
+	proxy "github.com/operator-framework/operator-sdk/pkg/ansible/proxy"
 	"github.com/operator-framework/operator-sdk/pkg/util/k8sutil"
-
+	sdkVersion "github.com/operator-framework/operator-sdk/version"
+	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
+	"sigs.k8s.io/controller-runtime/pkg/client/config"
+	"sigs.k8s.io/controller-runtime/pkg/manager"
 )
 
 func NewLocalCmd() *cobra.Command {
@@ -66,8 +73,15 @@ const (
 func upLocalFunc(cmd *cobra.Command, args []string) {
 	mustKubeConfig()
 	cmdutil.MustInProjectRoot()
-	c := cmdutil.GetConfig()
-	upLocal(c.ProjectName)
+	switch cmdutil.GetOperatorType() {
+	case cmdutil.OperatorTypeGo:
+		c := cmdutil.GetConfig()
+		upLocal(c.ProjectName)
+	case cmdutil.OperatorTypeAnsible:
+		upLocalAnsible()
+	default:
+		cmdError.ExitWithError(cmdError.ExitError, fmt.Errorf("failed to determine operator type"))
+	}
 }
 
 // mustKubeConfig checks if the kubeconfig file exists.
@@ -112,3 +126,37 @@ func upLocal(projectName string) {
 		cmdError.ExitWithError(cmdError.ExitError, fmt.Errorf("failed to run operator locally: %v", err))
 	}
 }
+
+func upLocalAnsible() {
+	mgr, err := manager.New(config.GetConfigOrDie(), manager.Options{Namespace: namespace})
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	printVersion()
+	done := make(chan error)
+
+	// start the proxy
+	proxy.RunProxy(done, proxy.Options{
+		Address:    "localhost",
+		Port:       8888,
+		KubeConfig: mgr.GetConfig(),
+	})
+
+	// start the operator
+	go ansibleOperator.Run(done, mgr, namespace)
+
+	// wait for either to finish
+	err = <-done
+	if err == nil {
+		logrus.Info("Exiting")
+	} else {
+		logrus.Fatal(err.Error())
+	}
+}
+
+func printVersion() {
+	logrus.Infof("Go Version: %s", runtime.Version())
+	logrus.Infof("Go OS/Arch: %s/%s", runtime.GOOS, runtime.GOARCH)
+	logrus.Infof("operator-sdk Version: %v", sdkVersion.Version)
+}

commands/operator-sdk/cmd/up/local.go

@@ -80,7 +80,7 @@ func Add(mgr manager.Manager, options Options) {
 		log.Fatal(err)
 	}
 
-	r := NewReconcileLoop(time.Minute*1, options.GVK, mgr.GetClient())
+	r := NewReconcileLoop(time.Minute*1, options.GVK, mgr.GetClient(), options.Namespace)
 	r.Stop = options.StopChannel
 	cs := &source.Channel{Source: r.Source}
 	cs.InjectStopChannel(options.StopChannel)

pkg/ansible/controller/controller.go

@@ -27,23 +27,25 @@ import (
 
 // ReconcileLoop - new loop
 type ReconcileLoop struct {
-	Source   chan event.GenericEvent
-	Stop     <-chan struct{}
-	GVK      schema.GroupVersionKind
-	Interval time.Duration
-	Client   client.Client
+	Source    chan event.GenericEvent
+	Stop      <-chan struct{}
+	GVK       schema.GroupVersionKind
+	Interval  time.Duration
+	Client    client.Client
+	Namespace string
 }
 
 // NewReconcileLoop - loop for a GVK.
 // The reconcilation loop is needed because the resync period
 // for the informer is not suitable for this use case.
-func NewReconcileLoop(interval time.Duration, gvk schema.GroupVersionKind, c client.Client) ReconcileLoop {
+func NewReconcileLoop(interval time.Duration, gvk schema.GroupVersionKind, c client.Client, namespace string) ReconcileLoop {
 	s := make(chan event.GenericEvent, 1025)
 	return ReconcileLoop{
-		Source:   s,
-		GVK:      gvk,
-		Interval: interval,
-		Client:   c,
+		Source:    s,
+		GVK:       gvk,
+		Interval:  interval,
+		Client:    c,
+		Namespace: namespace,
 	}
 }
 
@@ -57,7 +59,9 @@ func (r *ReconcileLoop) Start() {
 			case <-ticker.C:
 				// List all object for the GVK
 				ul := &unstructured.UnstructuredList{}
+				lo := client.ListOptions{}
 				ul.SetGroupVersionKind(r.GVK)
+				lo.InNamespace(r.Namespace)
 				err := r.Client.List(context.Background(), nil, ul)
 				if err != nil {
 					logrus.Warningf("unable to list resources for GV: %v during reconcilation", r.GVK)

pkg/ansible/controller/source.go

@@ -0,0 +1,56 @@
+// Copyright 2018 The Operator-SDK 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 operator
+
+import (
+	"log"
+	"math/rand"
+	"time"
+
+	"github.com/operator-framework/operator-sdk/pkg/ansible/controller"
+	"github.com/operator-framework/operator-sdk/pkg/ansible/runner"
+	"sigs.k8s.io/controller-runtime/pkg/manager"
+	"sigs.k8s.io/controller-runtime/pkg/runtime/signals"
+
+	"github.com/sirupsen/logrus"
+)
+
+// Run - A blocking function which starts a controller-runtime manager
+// It starts an Operator by reading in the values in `./watches.yaml`, adds a controller
+// to the manager, and finally running the manager.
+func Run(done chan error, mgr manager.Manager, namespace string) {
+	if namespace == "" {
+		namespace = "default"
+	}
+	watches, err := runner.NewFromWatches("./watches.yaml")
+	if err != nil {
+		logrus.Error("Failed to get watches")
+		done <- err
+		return
+	}
+	rand.Seed(time.Now().Unix())
+	c := signals.SetupSignalHandler()
+
+	for gvk, runner := range watches {
+		controller.Add(mgr, controller.Options{
+			GVK:         gvk,
+			Namespace:   namespace,
+			Runner:      runner,
+			StopChannel: c,
+		})
+	}
+	log.Fatal(mgr.Start(c))
+	done <- nil
+}