Latest revendoring deleted the cmd dir in varlink

Signed-off-by: baude <bbaude@redhat.com>

Closes: #672
Approved by: baude

3 files changed, 616 insertions, 0 deletions

diff --git a/vendor/github.com/varlink/go/cmd/varlink-go-interface-generator/generator_test.go b/vendor/github.com/varlink/go/cmd/varlink-go-interface-generator/generator_test.go
new file mode 100644
index 000000000..8e749f411
--- /dev/null
+++ b/vendor/github.com/varlink/go/cmd/varlink-go-interface-generator/generator_test.go
@@ -0,0 +1,90 @@
+package main
+
+import (
+	"strings"
+	"testing"
+)
+
+func expect(t *testing.T, expected string, returned string) {
+	if strings.Compare(returned, expected) != 0 {
+		t.Fatalf("Expected(%d): `%s`\nGot(%d): `%s`\n",
+			len(expected), expected,
+			len(returned), returned)
+	}
+}
+
+func TestIDLParser(t *testing.T) {
+	pkgname, b, err := generateTemplate(`
+# Interface to jump a spacecraft to another point in space. The 
+# FTL Drive is the propulsion system to achieve faster-than-light
+# travel through space. A ship making a properly calculated
+# jump can arrive safely in planetary orbit, or alongside other
+# ships or spaceborne objects.
+interface org.example.ftl
+
+# The current state of the FTL drive and the amount of fuel
+# available to jump.
+type DriveCondition (
+  state: (idle, spooling, busy),
+  booster: bool,
+  active_engines: [](id: int, state: bool),
+  tylium_level: int
+)
+
+# Speed, trajectory and jump duration is calculated prior to
+# activating the FTL drive.
+type DriveConfiguration (
+  speed: int,
+  trajectory: int,
+  duration: int
+)
+
+# The galactic coordinates use the Sun as the origin. Galactic
+# longitude is measured with primary direction from the Sun to
+# the center of the galaxy in the galactic plane, while the
+# galactic latitude measures the angle of the object above the
+# galactic plane.
+type Coordinate (
+  longitude: float,
+  latitude: float,
+  distance: int
+)
+
+# Monitor the drive. The method will reply with an update whenever
+# the drive's state changes
+method Monitor() -> (condition: DriveCondition)
+
+# Calculate the drive's jump parameters from the current
+# position to the target position in the galaxy
+method CalculateConfiguration(
+  current: Coordinate,
+  target: Coordinate
+) -> (configuration: DriveConfiguration)
+
+# Jump to the calculated point in space
+method Jump(configuration: DriveConfiguration) -> ()
+
+# There is not enough tylium to jump with the given parameters
+error NotEnoughEnergy ()
+
+# The supplied parameters are outside the supported range
+error ParameterOutOfRange (field: string)
+
+# some more coverage
+method Foo(interface: string) -> (ret: (go: string, switch: bool, more: (t:bool, f:bool)))
+
+# some more coverage
+method TestMap(map: [string]string) -> (map: [string](i: int, val: string))
+method TestSet(set: [string]()) -> (set: [string]())
+method TestObject(object: object) -> (object: object)
+	`)
+
+	if err != nil {
+		t.Fatalf("Error parsing %v", err)
+	}
+	expect(t, "orgexampleftl", pkgname)
+	if len(b) <= 0 {
+		t.Fatal("No generated go source")
+	}
+	// FIXME: compare b.String() against expected output
+}
diff --git a/vendor/github.com/varlink/go/cmd/varlink-go-interface-generator/main.go b/vendor/github.com/varlink/go/cmd/varlink-go-interface-generator/main.go
new file mode 100644
index 000000000..2db4e5cfd
--- /dev/null
+++ b/vendor/github.com/varlink/go/cmd/varlink-go-interface-generator/main.go
@@ -0,0 +1,354 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"go/format"
+	"io/ioutil"
+	"os"
+	"path"
+	"strings"
+
+	"github.com/varlink/go/varlink/idl"
+)
+
+func writeType(b *bytes.Buffer, t *idl.Type, json bool, ident int) {
+	switch t.Kind {
+	case idl.TypeBool:
+		b.WriteString("bool")
+
+	case idl.TypeInt:
+		b.WriteString("int64")
+
+	case idl.TypeFloat:
+		b.WriteString("float64")
+
+	case idl.TypeString, idl.TypeEnum:
+		b.WriteString("string")
+
+	case idl.TypeObject:
+		b.WriteString("json.RawMessage")
+
+	case idl.TypeArray:
+		b.WriteString("[]")
+		writeType(b, t.ElementType, json, ident)
+
+	case idl.TypeMap:
+		b.WriteString("map[string]")
+		writeType(b, t.ElementType, json, ident)
+
+	case idl.TypeMaybe:
+		b.WriteString("*")
+		writeType(b, t.ElementType, json, ident)
+
+	case idl.TypeAlias:
+		b.WriteString(t.Alias)
+
+	case idl.TypeStruct:
+		if len(t.Fields) == 0 {
+			b.WriteString("struct{}")
+		} else {
+			b.WriteString("struct {\n")
+			for _, field := range t.Fields {
+				for i := 0; i < ident+1; i++ {
+					b.WriteString("\t")
+				}
+
+				b.WriteString(strings.Title(field.Name) + " ")
+				writeType(b, field.Type, json, ident+1)
+				if json {
+					b.WriteString(" `json:\"" + field.Name)
+					if field.Type.Kind == idl.TypeMaybe {
+						b.WriteString(",omitempty")
+					}
+					b.WriteString("\"`")
+				}
+				b.WriteString("\n")
+			}
+			for i := 0; i < ident; i++ {
+				b.WriteString("\t")
+			}
+			b.WriteString("}")
+		}
+	}
+}
+
+func generateTemplate(description string) (string, []byte, error) {
+	description = strings.TrimRight(description, "\n")
+
+	midl, err := idl.New(description)
+	if err != nil {
+		return "", nil, err
+	}
+
+	pkgname := strings.Replace(midl.Name, ".", "", -1)
+
+	var b bytes.Buffer
+	b.WriteString("// Generated with github.com/varlink/go/cmd/varlink-go-interface-generator\n")
+	b.WriteString("package " + pkgname + "\n\n")
+	b.WriteString("@IMPORTS@\n\n")
+
+	b.WriteString("// Type declarations\n")
+	for _, a := range midl.Aliases {
+		b.WriteString("type " + a.Name + " ")
+		writeType(&b, a.Type, true, 0)
+		b.WriteString("\n\n")
+	}
+
+	b.WriteString("// Client method calls and reply readers\n")
+	for _, m := range midl.Methods {
+		b.WriteString("func " + m.Name + "(c__ *varlink.Connection, more__ bool, oneway__ bool")
+		for _, field := range m.In.Fields {
+			b.WriteString(", " + field.Name + "_ ")
+			writeType(&b, field.Type, false, 1)
+		}
+		b.WriteString(") error {\n")
+		if len(m.In.Fields) > 0 {
+			b.WriteString("\tvar in ")
+			writeType(&b, m.In, true, 1)
+			b.WriteString("\n")
+			for _, field := range m.In.Fields {
+				switch field.Type.Kind {
+				case idl.TypeStruct, idl.TypeArray, idl.TypeMap:
+					b.WriteString("\tin." + strings.Title(field.Name) + " = ")
+					writeType(&b, field.Type, true, 1)
+					b.WriteString("(" + field.Name + "_)\n")
+
+				default:
+					b.WriteString("\tin." + strings.Title(field.Name) + " = " + field.Name + "_\n")
+				}
+			}
+			b.WriteString("\treturn c__.Send(\"" + midl.Name + "." + m.Name + "\", in, more__, oneway__)\n" +
+				"}\n\n")
+		} else {
+			b.WriteString("\treturn c__.Send(\"" + midl.Name + "." + m.Name + "\", nil, more__, oneway__)\n" +
+				"}\n\n")
+		}
+
+		b.WriteString("func Read" + m.Name + "_(c__ *varlink.Connection")
+		for _, field := range m.Out.Fields {
+			b.WriteString(", " + field.Name + "_ *")
+			writeType(&b, field.Type, false, 1)
+		}
+		b.WriteString(") (bool, error) {\n")
+		if len(m.Out.Fields) > 0 {
+			b.WriteString("\tvar out ")
+			writeType(&b, m.Out, true, 1)
+			b.WriteString("\n")
+			b.WriteString("\tcontinues_, err := c__.Receive(&out)\n")
+		} else {
+			b.WriteString("\tcontinues_, err := c__.Receive(nil)\n")
+		}
+		b.WriteString("\tif err != nil {\n" +
+			"\t\treturn false, err\n" +
+			"\t}\n")
+		for _, field := range m.Out.Fields {
+			b.WriteString("\tif " + field.Name + "_ != nil {\n")
+			switch field.Type.Kind {
+			case idl.TypeStruct, idl.TypeArray, idl.TypeMap:
+				b.WriteString("\t\t*" + field.Name + "_ = ")
+				writeType(&b, field.Type, false, 2)
+				b.WriteString(" (out." + strings.Title(field.Name) + ")\n")
+
+			default:
+				b.WriteString("\t\t*" + field.Name + "_ = out." + strings.Title(field.Name) + "\n")
+			}
+			b.WriteString("\t}\n")
+		}
+
+		b.WriteString("\treturn continues_, nil\n" +
+			"}\n\n")
+	}
+
+	b.WriteString("// Service interface with all methods\n")
+	b.WriteString("type " + pkgname + "Interface interface {\n")
+	for _, m := range midl.Methods {
+		b.WriteString("\t" + m.Name + "(c__ VarlinkCall")
+		for _, field := range m.In.Fields {
+			b.WriteString(", " + field.Name + "_ ")
+			writeType(&b, field.Type, false, 1)
+		}
+		b.WriteString(") error\n")
+	}
+	b.WriteString("}\n\n")
+
+	b.WriteString("// Service object with all methods\n")
+	b.WriteString("type VarlinkCall struct{ varlink.Call }\n\n")
+
+	b.WriteString("// Reply methods for all varlink errors\n")
+	for _, e := range midl.Errors {
+		b.WriteString("func (c__ *VarlinkCall) Reply" + e.Name + "(")
+		for i, field := range e.Type.Fields {
+			if i > 0 {
+				b.WriteString(", ")
+			}
+			b.WriteString(field.Name + "_ ")
+			writeType(&b, field.Type, false, 1)
+		}
+		b.WriteString(") error {\n")
+		if len(e.Type.Fields) > 0 {
+			b.WriteString("\tvar out ")
+			writeType(&b, e.Type, true, 1)
+			b.WriteString("\n")
+			for _, field := range e.Type.Fields {
+				switch field.Type.Kind {
+				case idl.TypeStruct, idl.TypeArray, idl.TypeMap:
+					b.WriteString("\tout." + strings.Title(field.Name) + " = ")
+					writeType(&b, field.Type, true, 1)
+					b.WriteString("(" + field.Name + "_)\n")
+
+				default:
+					b.WriteString("\tout." + strings.Title(field.Name) + " = " + field.Name + "_\n")
+				}
+			}
+			b.WriteString("\treturn c__.ReplyError(\"" + midl.Name + "." + e.Name + "\", &out)\n")
+		} else {
+			b.WriteString("\treturn c__.ReplyError(\"" + midl.Name + "." + e.Name + "\", nil)\n")
+		}
+		b.WriteString("}\n\n")
+	}
+
+	b.WriteString("// Reply methods for all varlink methods\n")
+	for _, m := range midl.Methods {
+		b.WriteString("func (c__ *VarlinkCall) Reply" + m.Name + "(")
+		for i, field := range m.Out.Fields {
+			if i > 0 {
+				b.WriteString(", ")
+			}
+			b.WriteString(field.Name + "_ ")
+			writeType(&b, field.Type, false, 1)
+		}
+		b.WriteString(") error {\n")
+		if len(m.Out.Fields) > 0 {
+			b.WriteString("\tvar out ")
+			writeType(&b, m.Out, true, 1)
+			b.WriteString("\n")
+			for _, field := range m.Out.Fields {
+				switch field.Type.Kind {
+				case idl.TypeStruct, idl.TypeArray, idl.TypeMap:
+					b.WriteString("\tout." + strings.Title(field.Name) + " = ")
+					writeType(&b, field.Type, true, 1)
+					b.WriteString("(" + field.Name + "_)\n")
+
+				default:
+					b.WriteString("\tout." + strings.Title(field.Name) + " = " + field.Name + "_\n")
+				}
+			}
+			b.WriteString("\treturn c__.Reply(&out)\n")
+		} else {
+			b.WriteString("\treturn c__.Reply(nil)\n")
+		}
+		b.WriteString("}\n\n")
+	}
+
+	b.WriteString("// Dummy methods for all varlink methods\n")
+	for _, m := range midl.Methods {
+		b.WriteString("func (s__ *VarlinkInterface) " + m.Name + "(c__ VarlinkCall")
+		for _, field := range m.In.Fields {
+			b.WriteString(", " + field.Name + "_ ")
+			writeType(&b, field.Type, false, 1)
+		}
+		b.WriteString(") error {\n" +
+			"\treturn c__.ReplyMethodNotImplemented(\"" + m.Name + "\")\n" +
+			"}\n\n")
+	}
+
+	b.WriteString("// Method call dispatcher\n")
+	b.WriteString("func (s__ *VarlinkInterface) VarlinkDispatch(call varlink.Call, methodname string) error {\n" +
+		"\tswitch methodname {\n")
+	for _, m := range midl.Methods {
+		b.WriteString("\tcase \"" + m.Name + "\":\n")
+		if len(m.In.Fields) > 0 {
+			b.WriteString("\t\tvar in ")
+			writeType(&b, m.In, true, 2)
+			b.WriteString("\n")
+			b.WriteString("\t\terr := call.GetParameters(&in)\n" +
+				"\t\tif err != nil {\n" +
+				"\t\t\treturn call.ReplyInvalidParameter(\"parameters\")\n" +
+				"\t\t}\n")
+			b.WriteString("\t\treturn s__." + pkgname + "Interface." + m.Name + "(VarlinkCall{call}")
+			if len(m.In.Fields) > 0 {
+				for _, field := range m.In.Fields {
+					switch field.Type.Kind {
+					case idl.TypeStruct, idl.TypeArray, idl.TypeMap:
+						b.WriteString(", ")
+						writeType(&b, field.Type, false, 2)
+						b.WriteString("(in." + strings.Title(field.Name) + ")")
+
+					default:
+						b.WriteString(", in." + strings.Title(field.Name))
+					}
+				}
+			}
+			b.WriteString(")\n")
+		} else {
+			b.WriteString("\t\treturn s__." + pkgname + "Interface." + m.Name + "(VarlinkCall{call})\n")
+		}
+		b.WriteString("\n")
+	}
+	b.WriteString("\tdefault:\n" +
+		"\t\treturn call.ReplyMethodNotFound(methodname)\n" +
+		"\t}\n" +
+		"}\n\n")
+
+	b.WriteString("// Varlink interface name\n")
+	b.WriteString("func (s__ *VarlinkInterface) VarlinkGetName() string {\n" +
+		"\treturn `" + midl.Name + "`\n" + "}\n\n")
+
+	b.WriteString("// Varlink interface description\n")
+	b.WriteString("func (s__ *VarlinkInterface) VarlinkGetDescription() string {\n" +
+		"\treturn `" + midl.Description + "\n`\n}\n\n")
+
+	b.WriteString("// Service interface\n")
+	b.WriteString("type VarlinkInterface struct {\n" +
+		"\t" + pkgname + "Interface\n" +
+		"}\n\n")
+
+	b.WriteString("func VarlinkNew(m " + pkgname + "Interface) *VarlinkInterface {\n" +
+		"\treturn &VarlinkInterface{m}\n" +
+		"}\n")
+
+	ret_string := b.String()
+
+	if strings.Contains(ret_string, "json.RawMessage") {
+		ret_string = strings.Replace(ret_string, "@IMPORTS@", "import (\n\t\"github.com/varlink/go/varlink\"\n\t\"encoding/json\"\n)", 1)
+	} else {
+		ret_string = strings.Replace(ret_string, "@IMPORTS@", `import "github.com/varlink/go/varlink"`, 1)
+	}
+
+	pretty, err := format.Source([]byte(ret_string))
+	if err != nil {
+		return "", nil, err
+	}
+
+	return pkgname, pretty, nil
+}
+
+func generateFile(varlinkFile string) {
+	file, err := ioutil.ReadFile(varlinkFile)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error reading file '%s': %s\n", varlinkFile, err)
+		os.Exit(1)
+	}
+
+	pkgname, b, err := generateTemplate(string(file))
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error parsing file '%s': %s\n", varlinkFile, err)
+		os.Exit(1)
+	}
+
+	filename := path.Dir(varlinkFile) + "/" + pkgname + ".go"
+	err = ioutil.WriteFile(filename, b, 0660)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error writing file '%s': %s\n", filename, err)
+		os.Exit(1)
+	}
+}
+
+func main() {
+	if len(os.Args) != 2 {
+		fmt.Printf("Usage: %s <file>\n", os.Args[0])
+		os.Exit(1)
+	}
+	generateFile(os.Args[1])
+}
diff --git a/vendor/github.com/varlink/go/cmd/varlink-go-type-generator/main.go b/vendor/github.com/varlink/go/cmd/varlink-go-type-generator/main.go
new file mode 100644
index 000000000..46414b7bf
--- /dev/null
+++ b/vendor/github.com/varlink/go/cmd/varlink-go-type-generator/main.go
@@ -0,0 +1,172 @@
+package main
+
+import (
+	"fmt"
+	"go/ast"
+	"go/importer"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"log"
+	"os"
+)
+
+func IsBasicGoType(t types.Type, flag types.BasicInfo) bool {
+	switch u := t.(type) {
+	case *types.Basic:
+		if u.Info()&flag != 0 {
+			return true
+		}
+		return false
+	case *types.Named:
+		return IsBasicGoType(u.Underlying(), flag)
+	}
+	return false
+}
+
+func GoToVarlinkType(t types.Type) string {
+	if IsBasicGoType(t, types.IsBoolean) {
+		return "bool"
+	}
+
+	if IsBasicGoType(t, types.IsInteger) {
+		return "int"
+	}
+
+	if IsBasicGoType(t, types.IsFloat) {
+		return "float"
+	}
+
+	if IsBasicGoType(t, types.IsString) {
+		return "string"
+	}
+
+	switch u := t.(type) {
+	case *types.Basic:
+		return fmt.Sprintf("<<<%s>>>", t.String())
+
+	case *types.Named:
+		return u.Obj().Name()
+
+	case *types.Map:
+		if IsBasicGoType(u.Key(), types.IsString) {
+			return fmt.Sprintf("[string]%s", GoToVarlinkType(u.Elem()))
+		} else {
+			return fmt.Sprintf("<<<%s>>>", u.String())
+		}
+
+	case *types.Interface:
+		if u.Empty() {
+			return "()"
+		}
+		return fmt.Sprintf("<<<%s>>>", u.String())
+
+	case *types.Pointer:
+		return fmt.Sprintf("?%s", GoToVarlinkType(u.Elem()))
+
+	case *types.Array:
+		return fmt.Sprintf("[]%s", GoToVarlinkType(u.Elem()))
+
+	case *types.Slice:
+		return fmt.Sprintf("[]%s", GoToVarlinkType(u.Elem()))
+
+	case *types.Struct:
+		if u.NumFields() > 0 {
+			s := ""
+			for i := 0; i < u.NumFields(); i++ {
+				if i > 0 {
+					s += ",\n"
+				}
+				s += fmt.Sprintf("\t%s: %s",
+					u.Field(i).Name(), GoToVarlinkType(u.Field(i).Type()))
+			}
+
+			return fmt.Sprintf("(\n%s\n)", s)
+		}
+		return "()"
+
+	default:
+		return fmt.Sprintf("<<<%T %s>>>", t, u)
+	}
+}
+
+func PrintDefsUses(name string, fset *token.FileSet, files []*ast.File) error {
+	conf := types.Config{
+		Importer:    importer.Default(),
+		FakeImportC: true,
+	}
+
+	info := &types.Info{
+		Defs: make(map[*ast.Ident]types.Object),
+	}
+
+	_, err := conf.Check(name, fset, files, info)
+	if err != nil {
+		return err // type error
+	}
+
+	seen := map[string]interface{}{}
+
+	for id, obj := range info.Defs {
+		if obj == nil {
+			continue
+		}
+
+		if _, ok := seen[id.Name]; ok {
+			continue
+		}
+
+		/*
+			if !obj.Exported() || obj.Pkg().Name() != name {
+				continue
+			}
+		*/
+		switch f := obj.Type().Underlying().(type) {
+		case *types.Struct:
+			if f.NumFields() > 0 {
+				fmt.Printf("type %s %s\n\n", id.Name, GoToVarlinkType(f))
+			}
+		}
+		seen[id.Name] = nil
+	}
+
+	return nil
+}
+
+func main() {
+
+	path := os.Args[1]
+	fs := token.NewFileSet()
+
+	if stat, err := os.Stat(path); err == nil && stat.IsDir() {
+		pkgs, err := parser.ParseDir(fs, path, nil, 0)
+		if err != nil {
+			fmt.Printf("parsing dir '%s': %s", path, err)
+		}
+		for name, pkg := range pkgs {
+			log.Println("Found package:", name)
+
+			fset := make([]*ast.File, len(pkg.Files), len(pkg.Files))
+			idx := 0
+			for _, value := range pkg.Files {
+				fset[idx] = value
+				idx++
+			}
+
+			if err := PrintDefsUses(name, fs, fset); err != nil {
+				log.Print(err) // type error
+			}
+		}
+	} else {
+
+		fset, err := parser.ParseFile(fs, path, nil, 0)
+
+		if err != nil {
+			fmt.Printf("parsing file '%s': %s", path, err)
+		}
+		name := fset.Name.String()
+		if err := PrintDefsUses(name, fs, []*ast.File{fset}); err != nil {
+			log.Print(err) // type error
+		}
+	}
+}