Merge pull request #8400 from rhatdan/varlink

Remove varlink support from podman

13 files changed, 0 insertions, 2428 deletions

diff --git a/vendor/github.com/varlink/go/LICENSE b/vendor/github.com/varlink/go/LICENSE
deleted file mode 100644
index 261eeb9e9..000000000
--- a/vendor/github.com/varlink/go/LICENSE
+++ /dev/null
@@ -1,201 +0,0 @@
-                                 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:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) 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
-
-      (d) 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.
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
deleted file mode 100644
index 98a983c5e..000000000
--- a/vendor/github.com/varlink/go/cmd/varlink-go-interface-generator/main.go
+++ /dev/null
@@ -1,445 +0,0 @@
-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 writeDocString(b *bytes.Buffer, s string) {
-	if s == "" {
-		return
-	}
-
-	// Quote multi-line docstrings
-	b.WriteString("// " + strings.Replace(s, "\n", "\n// ", -1))
-	b.WriteString("\n")
-}
-
-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\n")
-
-	writeDocString(&b, midl.Doc)
-	b.WriteString("package " + pkgname + "\n\n")
-	b.WriteString("@IMPORTS@\n\n")
-
-	b.WriteString("// Generated type declarations\n\n")
-
-	for _, a := range midl.Aliases {
-		writeDocString(&b, a.Doc)
-		b.WriteString("type " + a.Name + " ")
-		writeType(&b, a.Type, true, 0)
-		b.WriteString("\n\n")
-	}
-
-	for _, a := range midl.Errors {
-		writeDocString(&b, a.Doc)
-		b.WriteString("type " + a.Name + " ")
-		writeType(&b, a.Type, true, 0)
-		b.WriteString("\nfunc (e " + a.Name + ") Error() string {\n")
-		b.WriteString("\treturn \"" + midl.Name + "." + a.Name + "\"\n")
-		b.WriteString("}\n\n")
-	}
-
-	b.WriteString("func Dispatch_Error(err error) error {\n")
-	b.WriteString("\tif e, ok := err.(*varlink.Error); ok {\n")
-	b.WriteString("\t\tswitch e.Name {\n")
-	for _, a := range midl.Errors {
-		b.WriteString("\t\tcase \"" + midl.Name + "." + a.Name + "\":\n")
-		b.WriteString("\t\t\terrorRawParameters := e.Parameters.(*json.RawMessage)\n")
-		b.WriteString("\t\t\tif errorRawParameters == nil {\n")
-		b.WriteString("\t\t\t\treturn e\n")
-		b.WriteString("\t\t\t}\n")
-		b.WriteString("\t\t\tvar param " + a.Name + "\n")
-		b.WriteString("\t\t\terr := json.Unmarshal(*errorRawParameters, &param)\n")
-		b.WriteString("\t\t\tif err != nil {\n")
-		b.WriteString("\t\t\t\treturn e\n")
-		b.WriteString("\t\t\t}\n")
-		b.WriteString("\t\t\treturn &param\n")
-	}
-	b.WriteString("\t\t}\n")
-	b.WriteString("\t}\n")
-	b.WriteString("\treturn err\n")
-	b.WriteString("}\n\n")
-
-	b.WriteString("// Generated client method calls\n\n")
-
-	for _, m := range midl.Methods {
-		writeDocString(&b, m.Doc)
-		b.WriteString("type " + m.Name + "_methods struct{}\n")
-		b.WriteString("func " + m.Name + "() " + m.Name + "_methods { return " + m.Name + "_methods{} }\n\n")
-
-		b.WriteString("func (m " + m.Name + "_methods) Call(c *varlink.Connection")
-		for _, field := range m.In.Fields {
-			b.WriteString(", " + field.Name + "_in_ ")
-			writeType(&b, field.Type, false, 1)
-		}
-		b.WriteString(") (")
-		for _, field := range m.Out.Fields {
-			b.WriteString(field.Name + "_out_ ")
-			writeType(&b, field.Type, false, 1)
-			b.WriteString(", ")
-		}
-		b.WriteString("err_ error) {\n")
-		b.WriteString("receive, err_ := m.Send(c, 0")
-		for _, field := range m.In.Fields {
-			b.WriteString(", " + field.Name + "_in_ ")
-		}
-		b.WriteString(")\n")
-		b.WriteString("if err_ != nil {\n" +
-			"\treturn\n" +
-			"}\n")
-		b.WriteString("\t")
-		for _, field := range m.Out.Fields {
-			b.WriteString(field.Name + "_out_ ")
-			b.WriteString(", ")
-		}
-		b.WriteString("_, err_ = receive()\n")
-		b.WriteString("\treturn\n" +
-			"}\n\n")
-
-		b.WriteString("func (m " + m.Name + "_methods) Send(c *varlink.Connection, flags uint64")
-		for _, field := range m.In.Fields {
-			b.WriteString(", " + field.Name + "_in_ ")
-			writeType(&b, field.Type, false, 1)
-		}
-		b.WriteString(") (func() (")
-		for _, field := range m.Out.Fields {
-			writeType(&b, field.Type, false, 1)
-			b.WriteString(", ")
-		}
-		b.WriteString("uint64, error), 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 + "_in_)\n")
-
-				default:
-					b.WriteString("\tin." + strings.Title(field.Name) + " = " + field.Name + "_in_\n")
-				}
-			}
-			b.WriteString("\treceive, err := c.Send(\"" + midl.Name + "." + m.Name + "\", in, flags)\n")
-		} else {
-			b.WriteString("\treceive, err := c.Send(\"" + midl.Name + "." + m.Name + "\", nil, flags)\n")
-		}
-		b.WriteString("\tif err != nil {\n" +
-			"\t\treturn nil, err\n" +
-			"\t}\n")
-		b.WriteString("\treturn func() (")
-		for _, field := range m.Out.Fields {
-			b.WriteString(field.Name + "_out_ ")
-			writeType(&b, field.Type, false, 3)
-			b.WriteString(", ")
-		}
-		b.WriteString("flags uint64, err error) {\n")
-		if len(m.Out.Fields) > 0 {
-			b.WriteString("\t\tvar out ")
-			writeType(&b, m.Out, true, 2)
-			b.WriteString("\n")
-			b.WriteString("\t\tflags, err = receive(&out)\n")
-		} else {
-			b.WriteString("\t\tflags, err = receive(nil)\n")
-		}
-		b.WriteString("\t\tif err != nil {\n" +
-			"\t\t\terr = Dispatch_Error(err)\n" +
-			"\t\t\treturn\n" +
-			"\t\t}\n")
-		for _, field := range m.Out.Fields {
-			b.WriteString("\t\t" + field.Name + "_out_ = ")
-			switch field.Type.Kind {
-			case idl.TypeStruct, idl.TypeArray, idl.TypeMap:
-				writeType(&b, field.Type, false, 2)
-				b.WriteString("(out." + strings.Title(field.Name) + ")\n")
-
-			default:
-				b.WriteString("out." + strings.Title(field.Name) + "\n")
-			}
-		}
-		b.WriteString("\t\treturn\n" +
-			"\t}, nil\n")
-		b.WriteString("}\n\n")
-	}
-
-	b.WriteString("// Generated service interface with all methods\n\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("// Generated service object with all methods\n\n")
-
-	b.WriteString("type VarlinkCall struct{ varlink.Call }\n\n")
-
-	b.WriteString("// Generated reply methods for all varlink errors\n\n")
-
-	for _, e := range midl.Errors {
-		writeDocString(&b, e.Doc)
-		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")
-		b.WriteString("\tvar out " + e.Name + "\n")
-		if len(e.Type.Fields) > 0 {
-			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")
-		b.WriteString("}\n\n")
-	}
-
-	b.WriteString("// Generated reply methods for all varlink methods\n\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("// Generated dummy implementations for all varlink methods\n\n")
-
-	for _, m := range midl.Methods {
-		writeDocString(&b, m.Doc)
-		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(\"" + midl.Name + "." + m.Name + "\")\n" +
-			"}\n\n")
-	}
-
-	b.WriteString("// Generated method call dispatcher\n\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("// Generated varlink interface name\n\n")
-
-	b.WriteString("func (s *VarlinkInterface) VarlinkGetName() string {\n" +
-		"\treturn `" + midl.Name + "`\n" + "}\n\n")
-
-	b.WriteString("// Generated varlink interface description\n\n")
-
-	// Special-quote backtick, it cannot be part of a backtick-quoted string
-	b.WriteString("func (s *VarlinkInterface) VarlinkGetDescription() string {\n" +
-		"\treturn `" + strings.Replace(midl.Description, "`", "` + \"`\" + `", -1) + "\n`\n}\n\n")
-
-	b.WriteString("// Generated service interface\n\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/varlink/bridge.go b/vendor/github.com/varlink/go/varlink/bridge.go
deleted file mode 100644
index c478dcd88..000000000
--- a/vendor/github.com/varlink/go/varlink/bridge.go
+++ /dev/null
@@ -1,65 +0,0 @@
-// +build !windows
-
-package varlink
-
-import (
-	"bufio"
-	"io"
-	"net"
-	"os"
-	"os/exec"
-)
-
-type PipeCon struct {
-	net.Conn
-	cmd    *exec.Cmd
-	reader *io.ReadCloser
-	writer *io.WriteCloser
-}
-
-func (p PipeCon) Close() error {
-	err1 := (*p.reader).Close()
-	err2 := (*p.writer).Close()
-	if err1 != nil {
-		return err1
-	}
-	if err2 != nil {
-		return err2
-	}
-	p.cmd.Wait()
-
-	return nil
-}
-
-// NewBridgeWithStderr returns a new connection with the given bridge.
-func NewBridgeWithStderr(bridge string, stderr io.Writer) (*Connection, error) {
-	//var err error
-
-	c := Connection{}
-	cmd := exec.Command("sh", "-c", bridge)
-	cmd.Stderr = stderr
-	r, err := cmd.StdoutPipe()
-	if err != nil {
-		return nil, err
-	}
-	w, err := cmd.StdinPipe()
-	if err != nil {
-		return nil, err
-	}
-	c.conn = PipeCon{nil, cmd, &r, &w}
-	c.address = ""
-	c.Reader = bufio.NewReader(r)
-	c.Writer = bufio.NewWriter(w)
-
-	err = cmd.Start()
-	if err != nil {
-		return nil, err
-	}
-
-	return &c, nil
-}
-
-// NewBridge returns a new connection with the given bridge.
-func NewBridge(bridge string) (*Connection, error) {
-	return NewBridgeWithStderr(bridge, os.Stderr)
-}
diff --git a/vendor/github.com/varlink/go/varlink/bridge_windows.go b/vendor/github.com/varlink/go/varlink/bridge_windows.go
deleted file mode 100644
index 42953b871..000000000
--- a/vendor/github.com/varlink/go/varlink/bridge_windows.go
+++ /dev/null
@@ -1,63 +0,0 @@
-package varlink
-
-import (
-	"bufio"
-	"io"
-	"net"
-	"os"
-	"os/exec"
-)
-
-type PipeCon struct {
-	net.Conn
-	cmd    *exec.Cmd
-	reader *io.ReadCloser
-	writer *io.WriteCloser
-}
-
-func (p PipeCon) Close() error {
-	err1 := (*p.reader).Close()
-	err2 := (*p.writer).Close()
-	if err1 != nil {
-		return err1
-	}
-	if err2 != nil {
-		return err2
-	}
-	p.cmd.Wait()
-
-	return nil
-}
-
-// NewBridgeWithStderr returns a new connection with the given bridge.
-func NewBridgeWithStderr(bridge string, stderr io.Writer) (*Connection, error) {
-	//var err error
-
-	c := Connection{}
-	cmd := exec.Command("cmd", "/C", bridge)
-	cmd.Stderr = stderr
-	r, err := cmd.StdoutPipe()
-	if err != nil {
-		return nil, err
-	}
-	w, err := cmd.StdinPipe()
-	if err != nil {
-		return nil, err
-	}
-	c.conn = PipeCon{nil, cmd, &r, &w}
-	c.address = ""
-	c.Reader = bufio.NewReader(r)
-	c.Writer = bufio.NewWriter(w)
-
-	err = cmd.Start()
-	if err != nil {
-		return nil, err
-	}
-
-	return &c, nil
-}
-
-// NewBridge returns a new connection with the given bridge.
-func NewBridge(bridge string) (*Connection, error) {
-	return NewBridgeWithStderr(bridge, os.Stderr)
-}
\ No newline at end of file
diff --git a/vendor/github.com/varlink/go/varlink/call.go b/vendor/github.com/varlink/go/varlink/call.go
deleted file mode 100644
index 0eaf24aca..000000000
--- a/vendor/github.com/varlink/go/varlink/call.go
+++ /dev/null
@@ -1,104 +0,0 @@
-package varlink
-
-import (
-	"bufio"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net"
-	"strings"
-)
-
-// Call is a method call retrieved by a Service. The connection from the
-// client can be terminated by returning an error from the call instead
-// of sending a reply or error reply.
-type Call struct {
-	*bufio.Reader
-	*bufio.Writer
-	Conn      *net.Conn
-	Request   *[]byte
-	In        *serviceCall
-	Continues bool
-	Upgrade   bool
-}
-
-// WantsMore indicates if the calling client accepts more than one reply to this method call.
-func (c *Call) WantsMore() bool {
-	return c.In.More
-}
-
-// WantsUpgrade indicates that the calling client wants the connection to be upgraded.
-func (c *Call) WantsUpgrade() bool {
-	return c.In.Upgrade
-}
-
-// IsOneway indicate that the calling client does not expect a reply.
-func (c *Call) IsOneway() bool {
-	return c.In.Oneway
-}
-
-// GetParameters retrieves the method call parameters.
-func (c *Call) GetParameters(p interface{}) error {
-	if c.In.Parameters == nil {
-		return fmt.Errorf("empty parameters")
-	}
-	return json.Unmarshal(*c.In.Parameters, p)
-}
-
-func (c *Call) sendMessage(r *serviceReply) error {
-	if c.In.Oneway {
-		return nil
-	}
-
-	b, e := json.Marshal(r)
-	if e != nil {
-		return e
-	}
-
-	b = append(b, 0)
-	_, e = c.Writer.Write(b)
-	if e != nil {
-		if e == io.EOF {
-			return io.ErrUnexpectedEOF
-		}
-		return e
-	}
-	e = c.Writer.Flush()
-	if e == io.EOF {
-		return io.ErrUnexpectedEOF
-	}
-	return e
-}
-
-// Reply sends a reply to this method call.
-func (c *Call) Reply(parameters interface{}) error {
-	if !c.Continues {
-		return c.sendMessage(&serviceReply{
-			Parameters: parameters,
-		})
-	}
-
-	if !c.In.More {
-		return fmt.Errorf("call did not set more, it does not expect continues")
-	}
-
-	return c.sendMessage(&serviceReply{
-		Continues:  true,
-		Parameters: parameters,
-	})
-}
-
-// ReplyError sends an error reply to this method call.
-func (c *Call) ReplyError(name string, parameters interface{}) error {
-	r := strings.LastIndex(name, ".")
-	if r <= 0 {
-		return fmt.Errorf("invalid error name")
-	}
-	if name[:r] == "org.varlink.service" {
-		return fmt.Errorf("refused to send org.varlink.service errors")
-	}
-	return c.sendMessage(&serviceReply{
-		Error:      name,
-		Parameters: parameters,
-	})
-}
diff --git a/vendor/github.com/varlink/go/varlink/connection.go b/vendor/github.com/varlink/go/varlink/connection.go
deleted file mode 100644
index 596caa825..000000000
--- a/vendor/github.com/varlink/go/varlink/connection.go
+++ /dev/null
@@ -1,291 +0,0 @@
-package varlink
-
-import (
-	"bufio"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net"
-	"strings"
-)
-
-// Message flags for Send(). More indicates that the client accepts more than one method
-// reply to this call. Oneway requests, that the service must not send a method reply to
-// this call. Continues indicates that the service will send more than one reply.
-const (
-	More      = 1 << iota
-	Oneway    = 1 << iota
-	Continues = 1 << iota
-	Upgrade   = 1 << iota
-)
-
-// Error is a varlink error returned from a method call.
-type Error struct {
-	Name       string
-	Parameters interface{}
-}
-
-func (e *Error) DispatchError() error {
-	errorRawParameters := e.Parameters.(*json.RawMessage)
-
-	switch e.Name {
-	case "org.varlink.service.InterfaceNotFound":
-		var param InterfaceNotFound
-		if errorRawParameters != nil {
-			err := json.Unmarshal(*errorRawParameters, &param)
-			if err != nil {
-				return e
-			}
-		}
-		return &param
-	case "org.varlink.service.MethodNotFound":
-		var param MethodNotFound
-		if errorRawParameters != nil {
-			err := json.Unmarshal(*errorRawParameters, &param)
-			if err != nil {
-				return e
-			}
-		}
-		return &param
-	case "org.varlink.service.MethodNotImplemented":
-		var param MethodNotImplemented
-		if errorRawParameters != nil {
-			err := json.Unmarshal(*errorRawParameters, &param)
-			if err != nil {
-				return e
-			}
-		}
-		return &param
-	case "org.varlink.service.InvalidParameter":
-		var param InvalidParameter
-		if errorRawParameters != nil {
-			err := json.Unmarshal(*errorRawParameters, &param)
-			if err != nil {
-				return e
-			}
-		}
-		return &param
-	}
-	return e
-}
-
-// Error returns the fully-qualified varlink error name.
-func (e *Error) Error() string {
-	return e.Name
-}
-
-// Connection is a connection from a client to a service.
-type Connection struct {
-	io.Closer
-	address string
-	conn    net.Conn
-	Reader  *bufio.Reader
-	Writer  *bufio.Writer
-}
-
-// Send sends a method call. It returns a receive() function which is called to retrieve the method reply.
-// If Send() is called with the `More`flag and the receive() function carries the `Continues` flag, receive()
-// can be called multiple times to retrieve multiple replies.
-func (c *Connection) Send(method string, parameters interface{}, flags uint64) (func(interface{}) (uint64, error), error) {
-	type call struct {
-		Method     string      `json:"method"`
-		Parameters interface{} `json:"parameters,omitempty"`
-		More       bool        `json:"more,omitempty"`
-		Oneway     bool        `json:"oneway,omitempty"`
-		Upgrade    bool        `json:"upgrade,omitempty"`
-	}
-
-	if (flags&More != 0) && (flags&Oneway != 0) {
-		return nil, &Error{
-			Name:       "org.varlink.InvalidParameter",
-			Parameters: "oneway",
-		}
-	}
-
-	if (flags&More != 0) && (flags&Upgrade != 0) {
-		return nil, &Error{
-			Name:       "org.varlink.InvalidParameter",
-			Parameters: "more",
-		}
-	}
-
-	m := call{
-		Method:     method,
-		Parameters: parameters,
-		More:       flags&More != 0,
-		Oneway:     flags&Oneway != 0,
-		Upgrade:    flags&Upgrade != 0,
-	}
-	b, err := json.Marshal(m)
-	if err != nil {
-		return nil, err
-	}
-
-	b = append(b, 0)
-	_, err = c.Writer.Write(b)
-	if err != nil {
-		if err == io.EOF {
-			return nil, io.ErrUnexpectedEOF
-		}
-		return nil, err
-	}
-
-	err = c.Writer.Flush()
-	if err != nil {
-		if err == io.EOF {
-			return nil, io.ErrUnexpectedEOF
-		}
-		return nil, err
-	}
-
-	receive := func(out_parameters interface{}) (uint64, error) {
-		type reply struct {
-			Parameters *json.RawMessage `json:"parameters"`
-			Continues  bool             `json:"continues"`
-			Error      string           `json:"error"`
-		}
-
-		out, err := c.Reader.ReadBytes('\x00')
-		if err != nil {
-			if err == io.EOF {
-				return 0, io.ErrUnexpectedEOF
-			}
-			return 0, err
-		}
-
-		var m reply
-		err = json.Unmarshal(out[:len(out)-1], &m)
-		if err != nil {
-			return 0, err
-		}
-
-		if m.Error != "" {
-			e := &Error{
-				Name:       m.Error,
-				Parameters: m.Parameters,
-			}
-			return 0, e.DispatchError()
-		}
-
-		if m.Parameters != nil {
-			json.Unmarshal(*m.Parameters, out_parameters)
-		}
-
-		if m.Continues {
-			return Continues, nil
-		}
-
-		return 0, nil
-	}
-
-	return receive, nil
-}
-
-// Call sends a method call and returns the method reply.
-func (c *Connection) Call(method string, parameters interface{}, out_parameters interface{}) error {
-	receive, err := c.Send(method, &parameters, 0)
-	if err != nil {
-		return err
-	}
-
-	_, err = receive(out_parameters)
-	return err
-}
-
-// GetInterfaceDescription requests the interface description string from the service.
-func (c *Connection) GetInterfaceDescription(name string) (string, error) {
-	type request struct {
-		Interface string `json:"interface"`
-	}
-	type reply struct {
-		Description string `json:"description"`
-	}
-
-	var r reply
-	err := c.Call("org.varlink.service.GetInterfaceDescription", request{Interface: name}, &r)
-	if err != nil {
-		return "", err
-	}
-
-	return r.Description, nil
-}
-
-// GetInfo requests information about the service.
-func (c *Connection) GetInfo(vendor *string, product *string, version *string, url *string, interfaces *[]string) error {
-	type reply struct {
-		Vendor     string   `json:"vendor"`
-		Product    string   `json:"product"`
-		Version    string   `json:"version"`
-		URL        string   `json:"url"`
-		Interfaces []string `json:"interfaces"`
-	}
-
-	var r reply
-	err := c.Call("org.varlink.service.GetInfo", nil, &r)
-	if err != nil {
-		return err
-	}
-
-	if vendor != nil {
-		*vendor = r.Vendor
-	}
-	if product != nil {
-		*product = r.Product
-	}
-	if version != nil {
-		*version = r.Version
-	}
-	if url != nil {
-		*url = r.URL
-	}
-	if interfaces != nil {
-		*interfaces = r.Interfaces
-	}
-
-	return nil
-}
-
-// Close terminates the connection.
-func (c *Connection) Close() error {
-	return c.conn.Close()
-}
-
-// NewConnection returns a new connection to the given address.
-func NewConnection(address string) (*Connection, error) {
-	var err error
-
-	words := strings.SplitN(address, ":", 2)
-
-	if len(words) != 2 {
-		return nil, fmt.Errorf("Protocol missing")
-	}
-
-	protocol := words[0]
-	addr := words[1]
-
-	// Ignore parameters after ';'
-	words = strings.SplitN(addr, ";", 2)
-	if words != nil {
-		addr = words[0]
-	}
-
-	switch protocol {
-	case "unix":
-		break
-
-	case "tcp":
-		break
-	}
-
-	c := Connection{}
-	c.conn, err = net.Dial(protocol, addr)
-	if err != nil {
-		return nil, err
-	}
-
-	c.address = address
-	c.Reader = bufio.NewReader(c.conn)
-	c.Writer = bufio.NewWriter(c.conn)
-
-	return &c, nil
-}
diff --git a/vendor/github.com/varlink/go/varlink/doc.go b/vendor/github.com/varlink/go/varlink/doc.go
deleted file mode 100644
index de1ed2380..000000000
--- a/vendor/github.com/varlink/go/varlink/doc.go
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
-Package varlink provides varlink client and server implementations. See http://varlink.org
-for more information about varlink.
-
-Example varlink interface definition in a org.example.this.varlink file:
-	interface org.example.this
-
-	method Ping(in: string) -> (out: string)
-
-Generated Go module in a orgexamplethis/orgexamplethis.go file. The generated module
-provides reply methods for all methods specified in the varlink interface description.
-The stub implementations return a MethodNotImplemented error; the service implementation
-using this module will override the methods with its own implementation.
-	// Generated with github.com/varlink/go/cmd/varlink-go-interface-generator
-	package orgexamplethis
-
-	import "github.com/varlink/go/varlink"
-
-	type orgexamplethisInterface interface {
-		Ping(c VarlinkCall, in string) error
-	}
-
-	type VarlinkCall struct{ varlink.Call }
-
-	func (c *VarlinkCall) ReplyPing(out string) error {
-		var out struct {
-			Out string `json:"out,omitempty"`
-		}
-		out.Out = out
-		return c.Reply(&out)
-	}
-
-	func (s *VarlinkInterface) Ping(c VarlinkCall, in string) error {
-		return c.ReplyMethodNotImplemented("Ping")
-	}
-
-	[...]
-
-Service implementing the interface and its method:
-	import ("orgexamplethis")
-
-	type Data struct {
-		orgexamplethis.VarlinkInterface
-		data string
-	}
-
-	data := Data{data: "test"}
-
-	func (d *Data) Ping(call orgexamplethis.VarlinkCall, ping string) error {
-		return call.ReplyPing(ping)
-	}
-
-	service, _ = varlink.NewService(
-	        "Example",
-	        "This",
-	        "1",
-	         "https://example.org/this",
-	)
-
-	service.RegisterInterface(orgexamplethis.VarlinkNew(&data))
-	err := service.Listen("unix:/run/org.example.this", 0)
-*/
-package varlink
diff --git a/vendor/github.com/varlink/go/varlink/idl/idl.go b/vendor/github.com/varlink/go/varlink/idl/idl.go
deleted file mode 100644
index b09b4798b..000000000
--- a/vendor/github.com/varlink/go/varlink/idl/idl.go
+++ /dev/null
@@ -1,497 +0,0 @@
-// Package idl provides a varlink interface description parser.
-package idl
-
-import (
-	"bytes"
-	"fmt"
-	"regexp"
-)
-
-// Valid TypeKind values.
-const (
-	TypeBool = iota
-	TypeInt
-	TypeFloat
-	TypeString
-	TypeObject
-	TypeArray
-	TypeMaybe
-	TypeMap
-	TypeStruct
-	TypeEnum
-	TypeAlias
-)
-
-// TypeKind specifies the type of an Type.
-type TypeKind uint
-
-// Type represents a varlink type. Types are method input and output parameters,
-// error output parameters, or custom defined types in the interface description.
-type Type struct {
-	Kind        TypeKind
-	ElementType *Type
-	Alias       string
-	Fields      []TypeField
-}
-
-// TypeField is a named member of a TypeStruct.
-type TypeField struct {
-	Name string
-	Type *Type
-}
-
-// Alias represents a named Type in the interface description.
-type Alias struct {
-	Name string
-	Doc  string
-	Type *Type
-}
-
-// Method represents a method defined in the interface description.
-type Method struct {
-	Name string
-	Doc  string
-	In   *Type
-	Out  *Type
-}
-
-// Error represents an error defined in the interface description.
-type Error struct {
-	Name string
-	Doc  string
-	Type *Type
-}
-
-// IDL represents a parsed varlink interface description with types, methods, errors and
-// documentation.
-type IDL struct {
-	Name        string
-	Doc         string
-	Description string
-	Members     []interface{}
-	Aliases     []*Alias
-	Methods     []*Method
-	Errors      []*Error
-}
-
-type parser struct {
-	input       string
-	position    int
-	lineStart   int
-	lastComment bytes.Buffer
-}
-
-func (p *parser) next() int {
-	r := -1
-
-	if p.position < len(p.input) {
-		r = int(p.input[p.position])
-	}
-
-	p.position++
-	return r
-}
-
-func (p *parser) backup() {
-	p.position--
-}
-
-func (p *parser) advance() bool {
-	for {
-		char := p.next()
-
-		if char == '\n' {
-			p.lineStart = p.position
-			p.lastComment.Reset()
-
-		} else if char == ' ' || char == '\t' {
-			// ignore
-
-		} else if char == '#' {
-			p.next()
-			start := p.position
-			for {
-				c := p.next()
-				if c < 0 || c == '\n' {
-					p.backup()
-					break
-				}
-			}
-			if p.lastComment.Len() > 0 {
-				p.lastComment.WriteByte('\n')
-			}
-			p.lastComment.WriteString(p.input[start:p.position])
-			p.next()
-
-		} else {
-			p.backup()
-			break
-		}
-	}
-
-	return p.position < len(p.input)
-}
-
-func (p *parser) advanceOnLine() {
-	for {
-		char := p.next()
-		if char != ' ' {
-			p.backup()
-			return
-		}
-	}
-}
-
-func (p *parser) readKeyword() string {
-	start := p.position
-
-	for {
-		char := p.next()
-		if char < 'a' || char > 'z' {
-			p.backup()
-			break
-		}
-	}
-
-	return p.input[start:p.position]
-}
-
-func (p *parser) readInterfaceName() string {
-	start := p.position
-	dnrx := regexp.MustCompile(`^[a-z]+(\.[a-z0-9]+([-][a-z0-9]+)*)+`)
-	name := dnrx.FindString(p.input[start:])
-	if name != "" {
-		if len(name) > 255 {
-			return ""
-		}
-		p.position += len(name)
-		return name
-	}
-	xdnrx := regexp.MustCompile(`^xn--[a-z0-9]+(\.[a-z0-9]+([-][a-z0-9]+)*)+`)
-	name = xdnrx.FindString(p.input[start:])
-	if name != "" {
-		if len(name) > 255 {
-			return ""
-		}
-		p.position += len(name)
-		return name
-	}
-	return ""
-}
-
-func (p *parser) readFieldName() string {
-	start := p.position
-
-	char := p.next()
-	if char < 'a' || char > 'z' {
-		p.backup()
-		return ""
-	}
-
-	for {
-		char := p.next()
-		if (char < 'A' || char > 'Z') && (char < 'a' || char > 'z') && (char < '0' || char > '9') && char != '_' {
-			p.backup()
-			break
-		}
-	}
-
-	return p.input[start:p.position]
-}
-
-func (p *parser) readTypeName() string {
-	start := p.position
-
-	for {
-		char := p.next()
-		if (char < 'A' || char > 'Z') && (char < 'a' || char > 'z') && (char < '0' || char > '9') {
-			p.backup()
-			break
-		}
-	}
-
-	return p.input[start:p.position]
-}
-
-func (p *parser) readStructType() *Type {
-	if p.next() != '(' {
-		p.backup()
-		return nil
-	}
-
-	t := &Type{Kind: TypeStruct}
-	t.Fields = make([]TypeField, 0)
-
-	char := p.next()
-	if char != ')' {
-		p.backup()
-
-		for {
-			field := TypeField{}
-
-			p.advance()
-			field.Name = p.readFieldName()
-			if field.Name == "" {
-				return nil
-			}
-
-			p.advance()
-
-			// Enums have no types, they are just a list of names
-			if p.next() == ':' {
-				if t.Kind == TypeEnum {
-					return nil
-				}
-
-				p.advance()
-				field.Type = p.readType()
-				if field.Type == nil {
-					return nil
-				}
-
-			} else {
-				t.Kind = TypeEnum
-				p.backup()
-			}
-
-			t.Fields = append(t.Fields, field)
-
-			p.advance()
-			char = p.next()
-			if char != ',' {
-				break
-			}
-		}
-
-		if char != ')' {
-			return nil
-		}
-	}
-
-	return t
-}
-
-func (p *parser) readType() *Type {
-	var t *Type
-
-	switch p.next() {
-	case '?':
-		e := p.readType()
-		if e == nil {
-			return nil
-		}
-		if e.Kind == TypeMaybe {
-			return nil
-		}
-		t = &Type{Kind: TypeMaybe, ElementType: e}
-
-	case '[':
-		var kind TypeKind
-
-		switch p.readKeyword() {
-		case "string":
-			kind = TypeMap
-
-		case "":
-			kind = TypeArray
-
-		default:
-			return nil
-		}
-
-		if p.next() != ']' {
-			return nil
-		}
-		e := p.readType()
-		if e == nil {
-			return nil
-		}
-		t = &Type{Kind: kind, ElementType: e}
-
-	default:
-		p.backup()
-		if keyword := p.readKeyword(); keyword != "" {
-			switch keyword {
-			case "bool":
-				t = &Type{Kind: TypeBool}
-
-			case "int":
-				t = &Type{Kind: TypeInt}
-
-			case "float":
-				t = &Type{Kind: TypeFloat}
-
-			case "string":
-				t = &Type{Kind: TypeString}
-
-			case "object":
-				t = &Type{Kind: TypeObject}
-			}
-
-		} else if name := p.readTypeName(); name != "" {
-			t = &Type{Kind: TypeAlias, Alias: name}
-
-		} else if t = p.readStructType(); t == nil {
-			return nil
-		}
-	}
-
-	return t
-}
-
-func (p *parser) readAlias(idl *IDL) (*Alias, error) {
-	a := &Alias{}
-
-	p.advance()
-	a.Doc = p.lastComment.String()
-	a.Name = p.readTypeName()
-	if a.Name == "" {
-		return nil, fmt.Errorf("missing type name")
-	}
-
-	p.advance()
-	a.Type = p.readType()
-	if a.Type == nil {
-		return nil, fmt.Errorf("missing type declaration")
-	}
-
-	return a, nil
-}
-
-func (p *parser) readMethod(idl *IDL) (*Method, error) {
-	m := &Method{}
-
-	p.advance()
-	m.Doc = p.lastComment.String()
-	m.Name = p.readTypeName()
-	if m.Name == "" {
-		return nil, fmt.Errorf("missing method type")
-	}
-
-	p.advance()
-	m.In = p.readType()
-	if m.In == nil {
-		return nil, fmt.Errorf("missing method input")
-	}
-
-	p.advance()
-	one := p.next()
-	two := p.next()
-	if (one != '-') || two != '>' {
-		return nil, fmt.Errorf("missing method '->' operator")
-	}
-
-	p.advance()
-	m.Out = p.readType()
-	if m.Out == nil {
-		return nil, fmt.Errorf("missing method output")
-	}
-
-	return m, nil
-}
-
-func (p *parser) readError(idl *IDL) (*Error, error) {
-	e := &Error{}
-
-	p.advance()
-	e.Doc = p.lastComment.String()
-	e.Name = p.readTypeName()
-	if e.Name == "" {
-		return nil, fmt.Errorf("missing error name")
-	}
-
-	p.advanceOnLine()
-	e.Type = p.readType()
-
-	return e, nil
-}
-
-func (p *parser) readIDL() (*IDL, error) {
-	if keyword := p.readKeyword(); keyword != "interface" {
-		return nil, fmt.Errorf("missing interface keyword")
-	}
-
-	idl := &IDL{
-		Members: make([]interface{}, 0),
-		Aliases: make([]*Alias, 0),
-		Methods: make([]*Method, 0),
-		Errors:  make([]*Error, 0),
-	}
-
-	p.advance()
-	idl.Doc = p.lastComment.String()
-	idl.Name = p.readInterfaceName()
-	if idl.Name == "" {
-		return nil, fmt.Errorf("interface name")
-	}
-
-	// Check for duplicates
-	members := make(map[string]struct{}, 0)
-
-	for {
-		if !p.advance() {
-			break
-		}
-
-		switch keyword := p.readKeyword(); keyword {
-		case "type":
-			a, err := p.readAlias(idl)
-			if err != nil {
-				return nil, err
-			}
-			if _, ok := members[a.Name]; ok {
-				return nil, fmt.Errorf("type `%s` already defined", a.Name)
-			}
-			members[a.Name] = struct{}{}
-			idl.Aliases = append(idl.Aliases, a)
-			idl.Members = append(idl.Members, a)
-
-		case "method":
-			m, err := p.readMethod(idl)
-			if err != nil {
-				return nil, err
-			}
-			if _, ok := members[m.Name]; ok {
-				return nil, fmt.Errorf("method `%s` already defined", m.Name)
-			}
-			members[m.Name] = struct{}{}
-			idl.Methods = append(idl.Methods, m)
-			idl.Members = append(idl.Members, m)
-
-		case "error":
-			e, err := p.readError(idl)
-			if err != nil {
-				return nil, err
-			}
-			if _, ok := members[e.Name]; ok {
-				return nil, fmt.Errorf("error `%s` already defined", e.Name)
-			}
-			members[e.Name] = struct{}{}
-			idl.Errors = append(idl.Errors, e)
-			idl.Members = append(idl.Members, e)
-
-		default:
-			return nil, fmt.Errorf("unknown keyword '%s'", keyword)
-		}
-	}
-
-	return idl, nil
-}
-
-// New parses a varlink interface description.
-func New(description string) (*IDL, error) {
-	p := &parser{input: description}
-
-	p.advance()
-	idl, err := p.readIDL()
-	if err != nil {
-		return nil, err
-	}
-
-	if len(idl.Methods) == 0 {
-		return nil, fmt.Errorf("no methods defined")
-	}
-
-	idl.Description = description
-	return idl, nil
-}
diff --git a/vendor/github.com/varlink/go/varlink/orgvarlinkservice.go b/vendor/github.com/varlink/go/varlink/orgvarlinkservice.go
deleted file mode 100644
index 600c99d34..000000000
--- a/vendor/github.com/varlink/go/varlink/orgvarlinkservice.go
+++ /dev/null
@@ -1,162 +0,0 @@
-package varlink
-
-// The requested interface was not found.
-type InterfaceNotFound struct {
-	Interface string `json:"interface"`
-}
-
-func (e InterfaceNotFound) Error() string {
-	return "org.varlink.service.InterfaceNotFound"
-}
-
-// The requested method was not found
-type MethodNotFound struct {
-	Method string `json:"method"`
-}
-
-func (e MethodNotFound) Error() string {
-	return "org.varlink.service.MethodNotFound"
-}
-
-// The interface defines the requested method, but the service does not
-// implement it.
-type MethodNotImplemented struct {
-	Method string `json:"method"`
-}
-
-func (e MethodNotImplemented) Error() string {
-	return "org.varlink.service.MethodNotImplemented"
-}
-
-// One of the passed parameters is invalid.
-type InvalidParameter struct {
-	Parameter string `json:"parameter"`
-}
-
-func (e InvalidParameter) Error() string {
-	return "org.varlink.service.InvalidParameter"
-}
-
-func doReplyError(c *Call, name string, parameters interface{}) error {
-	return c.sendMessage(&serviceReply{
-		Error:      name,
-		Parameters: parameters,
-	})
-}
-
-// ReplyInterfaceNotFound sends a org.varlink.service errror reply to this method call
-func (c *Call) ReplyInterfaceNotFound(interfaceA string) error {
-	var out InterfaceNotFound
-	out.Interface = interfaceA
-	return doReplyError(c, "org.varlink.service.InterfaceNotFound", &out)
-}
-
-// ReplyMethodNotFound sends a org.varlink.service errror reply to this method call
-func (c *Call) ReplyMethodNotFound(method string) error {
-	var out MethodNotFound
-	out.Method = method
-	return doReplyError(c, "org.varlink.service.MethodNotFound", &out)
-}
-
-// ReplyMethodNotImplemented sends a org.varlink.service errror reply to this method call
-func (c *Call) ReplyMethodNotImplemented(method string) error {
-	var out MethodNotImplemented
-	out.Method = method
-	return doReplyError(c, "org.varlink.service.MethodNotImplemented", &out)
-}
-
-// ReplyInvalidParameter sends a org.varlink.service errror reply to this method call
-func (c *Call) ReplyInvalidParameter(parameter string) error {
-	var out InvalidParameter
-	out.Parameter = parameter
-	return doReplyError(c, "org.varlink.service.InvalidParameter", &out)
-}
-
-func (c *Call) replyGetInfo(vendor string, product string, version string, url string, interfaces []string) error {
-	var out struct {
-		Vendor     string   `json:"vendor,omitempty"`
-		Product    string   `json:"product,omitempty"`
-		Version    string   `json:"version,omitempty"`
-		URL        string   `json:"url,omitempty"`
-		Interfaces []string `json:"interfaces,omitempty"`
-	}
-	out.Vendor = vendor
-	out.Product = product
-	out.Version = version
-	out.URL = url
-	out.Interfaces = interfaces
-	return c.Reply(&out)
-}
-
-func (c *Call) replyGetInterfaceDescription(description string) error {
-	var out struct {
-		Description string `json:"description,omitempty"`
-	}
-	out.Description = description
-	return c.Reply(&out)
-}
-
-func (s *Service) orgvarlinkserviceDispatch(c Call, methodname string) error {
-	switch methodname {
-	case "GetInfo":
-		return s.getInfo(c)
-	case "GetInterfaceDescription":
-		var in struct {
-			Interface string `json:"interface"`
-		}
-		err := c.GetParameters(&in)
-		if err != nil {
-			return c.ReplyInvalidParameter("parameters")
-		}
-		return s.getInterfaceDescription(c, in.Interface)
-
-	default:
-		return c.ReplyMethodNotFound(methodname)
-	}
-}
-
-func (s *orgvarlinkserviceInterface) VarlinkDispatch(call Call, methodname string) error {
-	return nil
-}
-
-func (s *orgvarlinkserviceInterface) VarlinkGetName() string {
-	return `org.varlink.service`
-}
-
-func (s *orgvarlinkserviceInterface) VarlinkGetDescription() string {
-	return `# The Varlink Service Interface is provided by every varlink service. It
-# describes the service and the interfaces it implements.
-interface org.varlink.service
-
-# Get a list of all the interfaces a service provides and information
-# about the implementation.
-method GetInfo() -> (
-  vendor: string,
-  product: string,
-  version: string,
-  url: string,
-  interfaces: []string
-)
-
-# Get the description of an interface that is implemented by this service.
-method GetInterfaceDescription(interface: string) -> (description: string)
-
-# The requested interface was not found.
-error InterfaceNotFound (interface: string)
-
-# The requested method was not found
-error MethodNotFound (method: string)
-
-# The interface defines the requested method, but the service does not
-# implement it.
-error MethodNotImplemented (method: string)
-
-# One of the passed parameters is invalid.
-error InvalidParameter (parameter: string)`
-}
-
-type orgvarlinkserviceInterface struct{}
-
-func orgvarlinkserviceNew() *orgvarlinkserviceInterface {
-	return &orgvarlinkserviceInterface{}
-}
diff --git a/vendor/github.com/varlink/go/varlink/resolver.go b/vendor/github.com/varlink/go/varlink/resolver.go
deleted file mode 100644
index f0f4487d2..000000000
--- a/vendor/github.com/varlink/go/varlink/resolver.go
+++ /dev/null
@@ -1,92 +0,0 @@
-package varlink
-
-// ResolverAddress is the well-known address of the varlink interface resolver,
-// it translates varlink interface names to varlink service addresses.
-const ResolverAddress = "unix:/run/org.varlink.resolver"
-
-// Resolver resolves varlink interface names to varlink addresses
-type Resolver struct {
-	address string
-	conn    *Connection
-}
-
-// Resolve resolves a varlink interface name to a varlink address.
-func (r *Resolver) Resolve(iface string) (string, error) {
-	type request struct {
-		Interface string `json:"interface"`
-	}
-	type reply struct {
-		Address string `json:"address"`
-	}
-
-	/* don't ask the resolver for itself */
-	if iface == "org.varlink.resolver" {
-		return r.address, nil
-	}
-
-	var rep reply
-	err := r.conn.Call("org.varlink.resolver.Resolve", &request{Interface: iface}, &rep)
-	if err != nil {
-		return "", err
-	}
-
-	return rep.Address, nil
-}
-
-// GetInfo requests information about the resolver.
-func (r *Resolver) GetInfo(vendor *string, product *string, version *string, url *string, interfaces *[]string) error {
-	type reply struct {
-		Vendor     string
-		Product    string
-		Version    string
-		URL        string
-		Interfaces []string
-	}
-
-	var rep reply
-	err := r.conn.Call("org.varlink.resolver.GetInfo", nil, &rep)
-	if err != nil {
-		return err
-	}
-
-	if vendor != nil {
-		*vendor = rep.Vendor
-	}
-	if product != nil {
-		*product = rep.Product
-	}
-	if version != nil {
-		*version = rep.Version
-	}
-	if url != nil {
-		*url = rep.URL
-	}
-	if interfaces != nil {
-		*interfaces = rep.Interfaces
-	}
-
-	return nil
-}
-
-// Close terminates the resolver.
-func (r *Resolver) Close() error {
-	return r.conn.Close()
-}
-
-// NewResolver returns a new resolver connected to the given address.
-func NewResolver(address string) (*Resolver, error) {
-	if address == "" {
-		address = ResolverAddress
-	}
-
-	c, err := NewConnection(address)
-	if err != nil {
-		return nil, err
-	}
-	r := Resolver{
-		address: address,
-		conn:    c,
-	}
-
-	return &r, nil
-}
diff --git a/vendor/github.com/varlink/go/varlink/service.go b/vendor/github.com/varlink/go/varlink/service.go
deleted file mode 100644
index bf13aa1de..000000000
--- a/vendor/github.com/varlink/go/varlink/service.go
+++ /dev/null
@@ -1,375 +0,0 @@
-package varlink
-
-import (
-	"bufio"
-	"encoding/json"
-	"fmt"
-	"net"
-	"os"
-	"strings"
-	"sync"
-	"time"
-)
-
-type dispatcher interface {
-	VarlinkDispatch(c Call, methodname string) error
-	VarlinkGetName() string
-	VarlinkGetDescription() string
-}
-
-type serviceCall struct {
-	Method     string           `json:"method"`
-	Parameters *json.RawMessage `json:"parameters,omitempty"`
-	More       bool             `json:"more,omitempty"`
-	Oneway     bool             `json:"oneway,omitempty"`
-	Upgrade    bool             `json:"upgrade,omitempty"`
-}
-
-type serviceReply struct {
-	Parameters interface{} `json:"parameters,omitempty"`
-	Continues  bool        `json:"continues,omitempty"`
-	Error      string      `json:"error,omitempty"`
-}
-
-// Service represents an active varlink service. In addition to the registered custom varlink Interfaces, every service
-// implements the org.varlink.service interface which allows clients to retrieve information about the
-// running service.
-type Service struct {
-	vendor       string
-	product      string
-	version      string
-	url          string
-	interfaces   map[string]dispatcher
-	names        []string
-	descriptions map[string]string
-	running      bool
-	listener     net.Listener
-	conncounter  int64
-	mutex        sync.Mutex
-	protocol     string
-	address      string
-}
-
-// ServiceTimoutError helps API users to special-case timeouts.
-type ServiceTimeoutError struct{}
-
-func (ServiceTimeoutError) Error() string {
-	return "service timeout"
-}
-
-func (s *Service) getInfo(c Call) error {
-	return c.replyGetInfo(s.vendor, s.product, s.version, s.url, s.names)
-}
-
-func (s *Service) getInterfaceDescription(c Call, name string) error {
-	if name == "" {
-		return c.ReplyInvalidParameter("interface")
-	}
-
-	description, ok := s.descriptions[name]
-	if !ok {
-		return c.ReplyInvalidParameter("interface")
-	}
-
-	return c.replyGetInterfaceDescription(description)
-}
-
-func (s *Service) HandleMessage(conn *net.Conn, reader *bufio.Reader, writer *bufio.Writer, request []byte) error {
-	var in serviceCall
-
-	err := json.Unmarshal(request, &in)
-
-	if err != nil {
-		return err
-	}
-
-	c := Call{
-		Conn:    conn,
-		Reader:  reader,
-		Writer:  writer,
-		In:      &in,
-		Request: &request,
-	}
-
-	r := strings.LastIndex(in.Method, ".")
-	if r <= 0 {
-		return c.ReplyInvalidParameter("method")
-	}
-
-	interfacename := in.Method[:r]
-	methodname := in.Method[r+1:]
-
-	if interfacename == "org.varlink.service" {
-		return s.orgvarlinkserviceDispatch(c, methodname)
-	}
-
-	// Find the interface and method in our service
-	iface, ok := s.interfaces[interfacename]
-	if !ok {
-		return c.ReplyInterfaceNotFound(interfacename)
-	}
-
-	return iface.VarlinkDispatch(c, methodname)
-}
-
-// Shutdown shuts down the listener of a running service.
-func (s *Service) Shutdown() {
-	s.running = false
-	s.mutex.Lock()
-	if s.listener != nil {
-		s.listener.Close()
-	}
-	s.mutex.Unlock()
-}
-
-func (s *Service) handleConnection(conn net.Conn, wg *sync.WaitGroup) {
-	defer func() { s.mutex.Lock(); s.conncounter--; s.mutex.Unlock(); wg.Done() }()
-	reader := bufio.NewReader(conn)
-	writer := bufio.NewWriter(conn)
-
-	for {
-		request, err := reader.ReadBytes('\x00')
-		if err != nil {
-			break
-		}
-
-		err = s.HandleMessage(&conn, reader, writer, request[:len(request)-1])
-		if err != nil {
-			// FIXME: report error
-			//fmt.Fprintf(os.Stderr, "handleMessage: %v", err)
-			break
-		}
-	}
-
-	conn.Close()
-}
-
-func (s *Service) teardown() {
-	s.mutex.Lock()
-	s.listener = nil
-	s.running = false
-	s.protocol = ""
-	s.address = ""
-	s.mutex.Unlock()
-}
-
-func (s *Service) parseAddress(address string) error {
-	words := strings.SplitN(address, ":", 2)
-	if len(words) != 2 {
-		return fmt.Errorf("Unknown protocol")
-	}
-
-	s.protocol = words[0]
-	s.address = words[1]
-
-	// Ignore parameters after ';'
-	words = strings.SplitN(s.address, ";", 2)
-	if words != nil {
-		s.address = words[0]
-	}
-
-	switch s.protocol {
-	case "unix":
-		break
-	case "tcp":
-		break
-
-	default:
-		return fmt.Errorf("Unknown protocol")
-	}
-
-	return nil
-}
-
-func (s *Service) GetListener() (*net.Listener, error) {
-	s.mutex.Lock()
-	l := s.listener
-	s.mutex.Unlock()
-	return &l, nil
-}
-
-func (s *Service) setListener() error {
-	l := activationListener()
-	if l == nil {
-		if s.protocol == "unix" && s.address[0] != '@' {
-			os.Remove(s.address)
-		}
-
-		var err error
-		l, err = net.Listen(s.protocol, s.address)
-		if err != nil {
-			return err
-		}
-
-		if s.protocol == "unix" && s.address[0] != '@' {
-			l.(*net.UnixListener).SetUnlinkOnClose(true)
-		}
-	}
-
-	s.mutex.Lock()
-	s.listener = l
-	s.mutex.Unlock()
-
-	return nil
-}
-
-func (s *Service) refreshTimeout(timeout time.Duration) error {
-	switch l := s.listener.(type) {
-	case *net.UnixListener:
-		if err := l.SetDeadline(time.Now().Add(timeout)); err != nil {
-			return err
-		}
-	case *net.TCPListener:
-		if err := l.SetDeadline(time.Now().Add(timeout)); err != nil {
-			return err
-		}
-
-	}
-	return nil
-}
-
-// Listen starts a Service.
-func (s *Service) Bind(address string) error {
-	s.mutex.Lock()
-	if s.running {
-		s.mutex.Unlock()
-		return fmt.Errorf("Init(): already running")
-	}
-	s.mutex.Unlock()
-
-	s.parseAddress(address)
-
-	err := s.setListener()
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-// Listen starts a Service.
-func (s *Service) Listen(address string, timeout time.Duration) error {
-	var wg sync.WaitGroup
-	defer func() { s.teardown(); wg.Wait() }()
-
-	err := s.Bind(address)
-	if err != nil {
-		return err
-	}
-
-	s.mutex.Lock()
-	s.running = true
-	l := s.listener
-	s.mutex.Unlock()
-
-	for s.running {
-		if timeout != 0 {
-			if err := s.refreshTimeout(timeout); err != nil {
-				return err
-			}
-		}
-		conn, err := l.Accept()
-		if err != nil {
-			if err.(net.Error).Timeout() {
-				s.mutex.Lock()
-				if s.conncounter == 0 {
-					s.mutex.Unlock()
-					return ServiceTimeoutError{}
-				}
-				s.mutex.Unlock()
-				continue
-			}
-			if !s.running {
-				return nil
-			}
-			return err
-		}
-		s.mutex.Lock()
-		s.conncounter++
-		s.mutex.Unlock()
-		wg.Add(1)
-		go s.handleConnection(conn, &wg)
-	}
-
-	return nil
-}
-
-// Listen starts a Service.
-func (s *Service) DoListen(timeout time.Duration) error {
-	var wg sync.WaitGroup
-	defer func() { s.teardown(); wg.Wait() }()
-
-	s.mutex.Lock()
-	l := s.listener
-	s.mutex.Unlock()
-
-	if l == nil {
-		return fmt.Errorf("No listener set")
-	}
-
-	s.mutex.Lock()
-	s.running = true
-	s.mutex.Unlock()
-
-	for s.running {
-		if timeout != 0 {
-			if err := s.refreshTimeout(timeout); err != nil {
-				return err
-			}
-		}
-		conn, err := l.Accept()
-		if err != nil {
-			if err.(net.Error).Timeout() {
-				s.mutex.Lock()
-				if s.conncounter == 0 {
-					s.mutex.Unlock()
-					return ServiceTimeoutError{}
-				}
-				s.mutex.Unlock()
-				continue
-			}
-			if !s.running {
-				return nil
-			}
-			return err
-		}
-		s.mutex.Lock()
-		s.conncounter++
-		s.mutex.Unlock()
-		wg.Add(1)
-		go s.handleConnection(conn, &wg)
-	}
-
-	return nil
-}
-
-// RegisterInterface registers a varlink.Interface containing struct to the Service
-func (s *Service) RegisterInterface(iface dispatcher) error {
-	name := iface.VarlinkGetName()
-	if _, ok := s.interfaces[name]; ok {
-		return fmt.Errorf("interface '%s' already registered", name)
-	}
-
-	if s.running {
-		return fmt.Errorf("service is already running")
-	}
-	s.interfaces[name] = iface
-	s.descriptions[name] = iface.VarlinkGetDescription()
-	s.names = append(s.names, name)
-
-	return nil
-}
-
-// NewService creates a new Service which implements the list of given varlink interfaces.
-func NewService(vendor string, product string, version string, url string) (*Service, error) {
-	s := Service{
-		vendor:       vendor,
-		product:      product,
-		version:      version,
-		url:          url,
-		interfaces:   make(map[string]dispatcher),
-		descriptions: make(map[string]string),
-	}
-	err := s.RegisterInterface(orgvarlinkserviceNew())
-
-	return &s, err
-}
diff --git a/vendor/github.com/varlink/go/varlink/socketactivation.go b/vendor/github.com/varlink/go/varlink/socketactivation.go
deleted file mode 100644
index a64c0dc8e..000000000
--- a/vendor/github.com/varlink/go/varlink/socketactivation.go
+++ /dev/null
@@ -1,63 +0,0 @@
-// +build !windows
-
-package varlink
-
-import (
-	"net"
-	"os"
-	"strconv"
-	"strings"
-	"syscall"
-)
-
-func activationListener() net.Listener {
-	pid, err := strconv.Atoi(os.Getenv("LISTEN_PID"))
-	if err != nil || pid != os.Getpid() {
-		return nil
-	}
-
-	nfds, err := strconv.Atoi(os.Getenv("LISTEN_FDS"))
-	if err != nil || nfds < 1 {
-		return nil
-	}
-
-	fd := -1
-
-	// If more than one file descriptor is passed, find the
-	// "varlink" tag. The first file descriptor is always 3.
-	if nfds > 1 {
-		fdnames, set := os.LookupEnv("LISTEN_FDNAMES")
-		if !set {
-			return nil
-		}
-
-		names := strings.Split(fdnames, ":")
-		if len(names) != nfds {
-			return nil
-		}
-
-		for i, name := range names {
-			if name == "varlink" {
-				fd = 3 + i
-				break
-			}
-		}
-
-		if fd < 0 {
-			return nil
-		}
-
-	} else {
-		fd = 3
-	}
-
-	syscall.CloseOnExec(fd)
-
-	file := os.NewFile(uintptr(fd), "varlink")
-	listener, err := net.FileListener(file)
-	if err != nil {
-		return nil
-	}
-
-	return listener
-}
diff --git a/vendor/github.com/varlink/go/varlink/socketactivation_windows.go b/vendor/github.com/varlink/go/varlink/socketactivation_windows.go
deleted file mode 100644
index fb0894531..000000000
--- a/vendor/github.com/varlink/go/varlink/socketactivation_windows.go
+++ /dev/null
@@ -1,7 +0,0 @@
-package varlink
-
-import "net"
-
-func activationListener() net.Listener {
-	return nil
-}