Aws metadata should start when no template is provided (#746)

Signed-off-by: Nicolas Degory <[email protected]>

Author: ndegory

docs/cmd/infrakit/util/init/README.md

@@ -29,7 +29,7 @@ of `init` works as follows:
   2. The CLI fetches this and evaluates it as a template.
     + The engine uses the `INFRAKIT_VARS_TEMPLATE` env to determine a variables JSON to
     initialize some variables.  These can be overridden by appropriately named `--var`
-    and `--metdata` flags in the command line.
+    and `--metadata` flags in the command line.
     + The engine uses the `--var` to set parameters in memory for the scope of *this*
     evaluation.  These are ephemeral and can override the defaults set in above.
     + The engine uses the `--metadata` to set parameters that will persist, as some
@@ -44,7 +44,7 @@ of `init` works as follows:
   renders a template.  Depending on the plugin implementation, values that are not known
   at this time may be deferred (as multipass = true -- see `swarm/flavor.go#31).
   7. The CLI renders the text blob from the `Init` field of the instance spec returned
-  by the `Prepare` method.  This will apply the same set of `--var` as varaibles.
+  by the `Prepare` method.  This will apply the same set of `--var` as variables.
   8. The CLI prints out the rendered init script
   9. If `--persist` is set, the CLI will commit the current state of the vars plugin
   (which was started in the beginning of this process).

pkg/cli/services.go

@@ -107,7 +107,7 @@ func templateProcessor(scope scope.Scope) (*pflag.FlagSet,
 
 	fs := pflag.NewFlagSet("template", pflag.ExitOnError)
 
-	globals := fs.StringSlice("var", []string{}, "key=value pairs of globally scoped variagbles")
+	globals := fs.StringSlice("var", []string{}, "key=value pairs of globally scoped variables")
 	yamlDoc := fs.BoolP("yaml", "y", false, "True if input is in yaml format; json is the default")
 	dump := fs.BoolP("dump", "x", false, "True to dump to output instead of executing")
 	singlePass := fs.BoolP("final", "f", false, "True to render template as the final pass")

pkg/manager/stored.go

@@ -15,7 +15,7 @@ type key struct {
 }
 
 type record struct {
-	// Handler is the actuall plugin used to process the input
+	// Handler is the actual plugin used to process the input
 	Handler plugin.Name
 
 	// Spec is a copy of the spec

pkg/plugin/flavor/kubernetes/README.md

@@ -87,9 +87,9 @@ wget -qO- https://get.docker.com/ | sh
 ### A Word on Security
 
 Since Kubeadm use Token to authorize nodes, initializing
-the Kubernetes requires:
+Kubernetes requires:
 
-Docken socke API server exposes the remote API, but it is protected by TLS. Infrakit intends to make access to kubernetes manager from the side, but we can not send commands such as `get nodes` yet.
+Docker engine exposes its remote API, but it is protected by TLS. Infrakit intends to make access to kubernetes manager from the side, but we can not send commands such as `get nodes` yet.
 For installation, we use [kubeadm](https://kubernetes.io/docs/admin/kubeadm/) and build a secure cluster.
 
 
@@ -102,25 +102,26 @@ Building the binaries - do this from the top level project directory:
 make binaries
 ```
 
-Start required plugins.  We use the `infrakit plugin start` utility and a `plugins.json` to start up all the plugins,
-along with the InfraKit manager:
+Start required plugins.
+We can use the plugin utility to start up all the plugins along with the InfraKit manager:
 
 ```shell
-infrakit-group-default
-infrakit-instance-vagrant
-infrakit-flavor-kubernetes
+export INFRAKIT_LEADER_FILE=$HOME/.infrakit/leader
+echo "manager1" > $INFRAKIT_LEADER_FILE
+export PATH=$PWD/build:$PATH
+infrakit plugin start manager group vagrant kubernetes &
 ```
 
 Now start up the cluster comprised of a manager and a worker group.  In this case, see `groups-master.json` where we will create a manager group of one node and in `group-worker.json` create a worker group of 3 nodes. The topology in this is a single ensemble of infrakit running on your local machine that manages 4 vagrant vms running Kubernetes.  
 At Kubernetes flavor, you should run manager group first.
 Worker group will try to connect to manager before start.
-And as this flavor based on kubeadm, currently it support only one manager node.
+And as this flavor is based on kubeadm, it currently supports only one manager node.
 
 ```shell
 infrakit group commit groups-manager.json
 ```
-Wait for manager comes up.
-As it need to install docker and kubeadm, it take a little time...
+Wait for manager to come up.
+As it needs to install docker and kubeadm, it takes a little time...
 
 ```shell
 infrakit group commit groups-worker.json

pkg/plugin/flavor/swarm/README.md

@@ -1,37 +1,54 @@
 [
     {
-        "Plugin" : "manager",
-        "Launch" : {
-            "os": {
-                "Cmd" : "infrakit-manager --name group  --proxy-for-group group-stateless os --leader-file {{env "INFRAKIT_HOME"}}/leader --store-dir {{env "INFRAKIT_HOME"}}/configs > {{env "INFRAKIT_HOME"}}/logs/manager.log 2>&1"
-            }
+      "Key": "manager",
+      "Launch": {
+        "inproc": {
+          "Kind": "manager",
+          "Options": {
+            "Name": "",
+            "Group": "group-stateless"
+          },
+	  "Settings": {
+		  "LeaderFile": "{{env "INFRAKIT_HOME"}}/leader",
+		  "StoreDir": "{{env "INFRAKIT_HOME"}}/configs"
+	  },
+          "Backend": "file"
         }
+      }
     }
     ,
     {
-        "Plugin" : "group-stateless",
-        "Launch" : {
-            "os": {
-                "Cmd" : "infrakit-group-default --poll-interval 10s --name group-stateless --log 5 > {{env "INFRAKIT_HOME"}}/logs/group-stateless.log 2>&1"
-            }
+      "Key": "group-stateless",
+      "Launch": {
+        "inproc": {
+          "Kind": "group",
+          "Options": {
+            "PollInterval": "10s",
+            "MaxParallelNum": 0,
+            "PollIntervalGroupSpec": "10s",
+            "PollIntervalGroupDetail": "10s"
+          }
         }
+      }
     }
     ,
     {
-        "Plugin" : "instance-vagrant",
-        "Launch" : {
-            "os" : {
-                "Cmd" : "infrakit-instance-vagrant --log 5 > {{env "INFRAKIT_HOME"}}/logs/instance-vagrant.log 2>&1"
-            }
+      "Key": "instance-vagrant",
+      "Launch": {
+        "inproc": {
+          "Kind": "vagrant",
+          "Options": {
+          }
         }
+      }
     }
     ,
     {
-        "Plugin" : "flavor-swarm",
-        "Launch" : {
-            "os" : {
-                "Cmd" : "infrakit-flavor-swarm --log 5 > {{env "INFRAKIT_HOME"}}/logs/flavor-swarm.log 2>&1"
-            }
+      "Key": "flavor-swarm",
+      "Launch": {
+        "inproc": {
+          "Kind": "swarm"
         }
+      }
     }
 ]

pkg/plugin/flavor/swarm/plugins.json

@@ -28,11 +28,11 @@ echo group > $leaderfile
 
 export INFRAKIT_HOME=$INFRAKIT_HOME
 
-infrakit plugin start --config-url file:///$PWD/examples/flavor/swarm/plugins.json --exec os \
+infrakit plugin start --config-url file:///$PWD/plugin/flavor/swarm/plugins.json \
 	 manager \
-	 group-stateless \
+	 group \
 	 flavor-swarm \
-	 instance-vagrant
+	 instance-vagrant &
 
 sleep 5
 

pkg/plugin/flavor/swarm/start-plugins.sh

@@ -59,7 +59,7 @@ func NewPlugin(options Options, stop <-chan struct{}) (*Context, error) {
 		providers = append(providers, &staticCreds)
 	}
 
-	if options.Region == "" {
+	if options.Region == "" || options.Region == "auto" {
 		log.Warn("region not specified, attempting to discover from EC2 instance metadata")
 		region, err := instance.GetRegion()
 		if err != nil {

pkg/provider/aws/plugin/metadata/builder.go

@@ -48,7 +48,7 @@ func (c *Context) start() {
 		c.poll = 1 * time.Minute
 	}
 
-	log.Info("Staring", "context", c, "poll", c.poll)
+	log.Info("Starting", "context", c, "poll", c.poll)
 	update := make(chan func(map[string]interface{}))
 	tick := time.Tick(c.poll)
 
@@ -58,6 +58,14 @@ func (c *Context) start() {
 	go func() {
 
 		for {
+			select {
+			case <-tick:
+			case <-c.stop:
+				log.Info("Stopping aws metadata")
+				close(update)
+				return
+			}
+
 			log.Debug("Running template to export metadata", "url", c.templateURL, "V", debugV)
 
 			t, err := template.NewTemplate(c.templateURL, c.templateOptions)
@@ -66,8 +74,8 @@ func (c *Context) start() {
 				update <- func(view map[string]interface{}) {
 					view["err"] = err.Error()
 				}
+				continue
 			}
-
 			// Note the actual exporting of the values is done via the 'export' function
 			// that are invoked as part of processing the template.
 			_, err = t.Render(c)
@@ -81,14 +89,6 @@ func (c *Context) start() {
 					delete(view, "err")
 				}
 			}
-
-			select {
-			case <-tick:
-			case <-c.stop:
-				log.Info("Stopping aws metadata")
-				close(update)
-				return
-			}
 		}
 
 	}()

pkg/provider/aws/plugin/metadata/template.go

@@ -58,7 +58,7 @@ infrakit plugin start terraform:terraform=inproc
 ```
 
 where the launch system will look for `Key` of `terraform`, and use the `inproc` launcher which uses the
-embeded `terraform` Kind.  That then will look for the `Options` field and provide that to the code
+embedded `terraform` Kind.  That then will look for the `Options` field and provide that to the code
 that is in `terraform.go`.
 
 Once you have the new fields defined and updated your `plugins.json` file to reflect these new changes,

pkg/run/v0/terraform/README.md

@@ -419,7 +419,7 @@ func (t *Template) Render(context interface{}) (string, error) {
 	return buff.String(), err
 }
 
-// converts a function of f(Context, ags...) to a regular template function
+// converts a function of f(Context, args...) to a regular template function
 func makeTemplateFunc(ctx Context, f interface{}) (interface{}, error) {
 
 	contextType := reflect.TypeOf((*Context)(nil)).Elem()