Initial version. Implements 'show'

Basic skeleton.  Can evaluate jsonnet and show the output as yaml or
json .. and that's about it.

.gitignore

+/kubecfg
+
 # Compiled Object files, Static and Dynamic libs (Shared Objects)
 *.o
 *.a

Makefile

+VERSION = dev-$(shell date +%FT%T%z)
+
+GO = go
+GO_FLAGS = -ldflags="-X main.version=$(VERSION)"
+
+all: kubecfg
+
+kubecfg:
+	$(GO) build $(GO_FLAGS) .
+
+test:
+	$(GO) test ./cmd/...
+
+clean:
+	$(RM) ./kubecfg
+
+.PHONY: all test clean kubecfg

cmd/root.go

+package cmd
+
+import (
+	"encoding/json"
+	goflag "flag"
+	"path/filepath"
+
+	"github.com/golang/glog"
+	"github.com/spf13/cobra"
+	jsonnet "github.com/strickyak/jsonnet_cgo"
+)
+
+func init() {
+	RootCmd.PersistentFlags().String("context", "", "The name of the kubeconfig context to use")
+	RootCmd.PersistentFlags().StringP("jpath", "J", "", "Additional jsonnet library search path")
+	RootCmd.PersistentFlags().AddGoFlagSet(goflag.CommandLine)
+	RootCmd.PersistentFlags().Set("logtostderr", "true")
+}
+
+// RootCmd is the root of cobra subcommand tree
+var RootCmd = &cobra.Command{
+	Use:           "kubecfg",
+	Short:         "Synchronise Kubernetes resources with config files",
+	SilenceErrors: true,
+	SilenceUsage:  true,
+	PersistentPreRun: func(cmd *cobra.Command, args []string) {
+		goflag.CommandLine.Parse([]string{})
+		glog.CopyStandardLogTo("INFO")
+	},
+}
+
+// JsonnetVM constructs a new jsonnet.VM, according to command line
+// flags
+func JsonnetVM(cmd *cobra.Command) (*jsonnet.VM, error) {
+	vm := jsonnet.Make()
+	flags := cmd.Flags()
+
+	jpath, err := flags.GetString("jpath")
+	if err != nil {
+		return nil, err
+	}
+	for _, p := range filepath.SplitList(jpath) {
+		glog.V(2).Infoln("Adding jsonnet path", p)
+		vm.JpathAdd(p)
+	}
+
+	return vm, nil
+}
+
+func evalFile(vm *jsonnet.VM, file string) (interface{}, error) {
+	var err error
+	jsonstr := ""
+	if file != "" {
+		jsonstr, err = vm.EvaluateFile(file)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	glog.V(4).Infof("jsonnet result is: %s\n", jsonstr)
+
+	var jsobj interface{}
+	err = json.Unmarshal([]byte(jsonstr), &jsobj)
+	if err != nil {
+		return nil, err
+	}
+
+	return jsobj, nil
+}

cmd/show.go

+package cmd
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/spf13/cobra"
+	"gopkg.in/yaml.v2"
+)
+
+func init() {
+	RootCmd.AddCommand(showCmd)
+	showCmd.PersistentFlags().StringP("file", "f", "", "Input jsonnet file")
+	showCmd.MarkFlagFilename("file", "jsonnet", "libsonnet")
+	showCmd.PersistentFlags().StringP("format", "o", "yaml", "Output format.  Supported values are: json, yaml")
+}
+
+var showCmd = &cobra.Command{
+	Use:   "show",
+	Short: "Show expanded resource definitions",
+	RunE: func(cmd *cobra.Command, args []string) error {
+		flags := cmd.Flags()
+		out := cmd.OutOrStdout()
+
+		vm, err := JsonnetVM(cmd)
+		if err != nil {
+			return err
+		}
+		defer vm.Destroy()
+
+		file, err := flags.GetString("file")
+		if err != nil {
+			return err
+		}
+		jsobj, err := evalFile(vm, file)
+		if err != nil {
+			return err
+		}
+
+		format, err := flags.GetString("format")
+		if err != nil {
+			return err
+		}
+		switch format {
+		case "yaml":
+			buf, err := yaml.Marshal(jsobj)
+			if err != nil {
+				return err
+			}
+			out.Write(buf)
+		case "json":
+			enc := json.NewEncoder(out)
+			enc.SetIndent("", "  ")
+			if err := enc.Encode(&jsobj); err != nil {
+				return err
+			}
+		default:
+			return fmt.Errorf("Unknown --format: %s", format)
+		}
+
+		return nil
+	},
+}

cmd/show_test.go

+package cmd
+
+import (
+	"bytes"
+	"encoding/json"
+	"path/filepath"
+	"reflect"
+	"testing"
+
+	"gopkg.in/yaml.v2"
+)
+
+func cmdOutput(t *testing.T, args []string) string {
+	var buf bytes.Buffer
+	RootCmd.SetOutput(&buf)
+	defer RootCmd.SetOutput(nil)
+
+	t.Log("Running args", args)
+	RootCmd.SetArgs(args)
+	if err := RootCmd.Execute(); err != nil {
+		t.Fatal("command failed:", err)
+	}
+
+	return buf.String()
+}
+
+func TestShow(t *testing.T) {
+	formats := map[string]func(string) (interface{}, error){
+		"json": func(text string) (ret interface{}, err error) {
+			err = json.Unmarshal([]byte(text), &ret)
+			return
+		},
+		"yaml": func(text string) (ret interface{}, err error) {
+			err = yaml.Unmarshal([]byte(text), &ret)
+			return
+		},
+	}
+
+	// Use the fact that JSON is also valid YAML ..
+	expected := `
+{
+  "nil": null,
+  "bool": true,
+  "number": 42,
+  "string": "bar",
+  "array": ["one", 2, [3]],
+  "object": {"foo": "bar"}
+}
+`
+
+	for format, parser := range formats {
+		expected, err := parser(expected)
+		if err != nil {
+			t.Errorf("error parsing *expected* value: %s", err)
+		}
+
+		output := cmdOutput(t, []string{"show",
+			"-J", filepath.FromSlash("../testdata/lib"),
+			"-f", filepath.FromSlash("../testdata/test.jsonnet"),
+			"-o", format,
+		})
+
+		t.Log("output is", output)
+		actual, err := parser(output)
+		if err != nil {
+			t.Errorf("error parsing output of format %s: %s", format, err)
+		} else if !reflect.DeepEqual(expected, actual) {
+			t.Errorf("format %s expected != actual: %s != %s", format, expected, actual)
+		}
+	}
+}

cmd/version.go

+package cmd
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+	jsonnet "github.com/strickyak/jsonnet_cgo"
+)
+
+func init() {
+	RootCmd.AddCommand(versionCmd)
+}
+
+// Version is overridden by main
+var Version = "(dev build)"
+
+var versionCmd = &cobra.Command{
+	Use:   "version",
+	Short: "Print version information",
+	Run: func(cmd *cobra.Command, args []string) {
+		out := cmd.OutOrStdout()
+		fmt.Fprintln(out, "kubecfg version:", Version)
+		fmt.Fprintln(out, "jsonnet version:", jsonnet.Version())
+	},
+}

cmd/version_test.go

+package cmd
+
+import (
+	"regexp"
+	"testing"
+)
+
+func TestVersion(t *testing.T) {
+	output := cmdOutput(t, []string{"version"})
+
+	// Also a good smoke-test that libjsonnet linked successfully
+	if !regexp.MustCompile(`jsonnet version: v[\d.]+`).MatchString(output) {
+		t.Error("Failed to find jsonnet version in:", output)
+	}
+}

main.go

+package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/anguslees/kubecfg/cmd"
+)
+
+// Version is overridden using `-X main.version` during release builds
+var version = "(dev build)"
+
+func main() {
+	cmd.Version = version
+
+	if err := cmd.RootCmd.Execute(); err != nil {
+		fmt.Println("got error")
+		fmt.Println("Error:", err)
+		os.Exit(1)
+	}
+}

testdata/lib/test.libsonnet

+{
+  nil: null,
+  bool: true,
+  number: 42,
+  string: "foo",
+  array: ["one", 2, [3]],
+  object: {
+    foo: "bar",
+  },
+}

testdata/test.jsonnet

+local test = import "test.libsonnet";
+
+test {
+  string: "bar",
+}

vendor/github.com/golang/glog/LICENSE

+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:
+
+You must give any other recipients of the Work or Derivative Works a copy of
+this License; and
+You must cause any modified files to carry prominent notices stating that You
+changed the files; and
+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
+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.

vendor/github.com/golang/glog/README

+glog
+====
+
+Leveled execution logs for Go.
+
+This is an efficient pure Go implementation of leveled logs in the
+manner of the open source C++ package
+	https://github.com/google/glog
+
+By binding methods to booleans it is possible to use the log package
+without paying the expense of evaluating the arguments to the log.
+Through the -vmodule flag, the package also provides fine-grained
+control over logging at the file level.
+
+The comment from glog.go introduces the ideas:
+
+	Package glog implements logging analogous to the Google-internal
+	C++ INFO/ERROR/V setup.  It provides functions Info, Warning,
+	Error, Fatal, plus formatting variants such as Infof. It
+	also provides V-style logging controlled by the -v and
+	-vmodule=file=2 flags.
+	
+	Basic examples:
+	
+		glog.Info("Prepare to repel boarders")
+	
+		glog.Fatalf("Initialization failed: %s", err)
+	
+	See the documentation for the V function for an explanation
+	of these examples:
+	
+		if glog.V(2) {
+			glog.Info("Starting transaction...")
+		}
+	
+		glog.V(2).Infoln("Processed", nItems, "elements")
+
+
+The repository contains an open source version of the log package
+used inside Google. The master copy of the source lives inside
+Google, not here. The code in this repo is for export only and is not itself
+under development. Feature requests will be ignored.
+
+Send bug reports to golang-nuts@googlegroups.com.

vendor/github.com/golang/glog/glog_file.go

+// Go support for leveled logs, analogous to https://code.google.com/p/google-glog/
+//
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// 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.
+
+// File I/O for logs.
+
+package glog
+
+import (
+	"errors"
+	"flag"
+	"fmt"
+	"os"
+	"os/user"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+)
+
+// MaxSize is the maximum size of a log file in bytes.
+var MaxSize uint64 = 1024 * 1024 * 1800
+
+// logDirs lists the candidate directories for new log files.
+var logDirs []string
+
+// If non-empty, overrides the choice of directory in which to write logs.
+// See createLogDirs for the full list of possible destinations.
+var logDir = flag.String("log_dir", "", "If non-empty, write log files in this directory")
+
+func createLogDirs() {
+	if *logDir != "" {
+		logDirs = append(logDirs, *logDir)
+	}
+	logDirs = append(logDirs, os.TempDir())
+}
+
+var (
+	pid      = os.Getpid()
+	program  = filepath.Base(os.Args[0])
+	host     = "unknownhost"
+	userName = "unknownuser"
+)
+
+func init() {
+	h, err := os.Hostname()
+	if err == nil {
+		host = shortHostname(h)
+	}
+
+	current, err := user.Current()
+	if err == nil {
+		userName = current.Username
+	}
+
+	// Sanitize userName since it may contain filepath separators on Windows.
+	userName = strings.Replace(userName, `\`, "_", -1)
+}
+