Added x/net/trace support to VRPC
The RPCs are now also monitored by the x/net/trace package. This
exports an HTTP interface at the /debug/requests endpoint. In order to
access this interface, an RPC endpoint __debug/http has been created
to serve HTTP requests over RPC. A tool has been added to send these
type of RPCs and serve the HTML responses over a local HTTP server.
MultiPart: 1/2
Change-Id: Ifa59370ec9ef6f4c7d51ba5ee38fe71f74617559
diff --git a/.godepcop b/.godepcop
index 8b61b8a..3e0ef43 100644
--- a/.godepcop
+++ b/.godepcop
@@ -15,6 +15,9 @@
<xtest allow="github.com/presotto/go-mdns-sd/..."/>
<xtest allow="github.com/shirou/gopsutil/..."/>
<xtest allow="golang.org/x/crypto/..."/>
+ <xtest allow="golang.org/x/net/context/..."/>
+ <xtest allow="golang.org/x/net/internal/timeseries/..."/>
+ <xtest allow="golang.org/x/net/trace/..."/>
<xtest allow="v.io/x/lib/..."/>
<xtest allow="v.io/x/ref/..."/>
</godepcop>
diff --git a/services/http/.api b/services/http/.api
new file mode 100644
index 0000000..31b5ac8
--- /dev/null
+++ b/services/http/.api
@@ -0,0 +1,43 @@
+pkg http, func HttpClient(string) HttpClientStub
+pkg http, func HttpServer(HttpServerMethods) HttpServerStub
+pkg http, method (*Request) VDLRead(vdl.Decoder) error
+pkg http, method (*Url) VDLRead(vdl.Decoder) error
+pkg http, method (Request) VDLIsZero() bool
+pkg http, method (Request) VDLWrite(vdl.Encoder) error
+pkg http, method (Url) VDLIsZero() bool
+pkg http, method (Url) VDLWrite(vdl.Encoder) error
+pkg http, type HttpClientMethods interface { RawDo }
+pkg http, type HttpClientMethods interface, RawDo(*context.T, Request, ...rpc.CallOpt) ([]byte, error)
+pkg http, type HttpClientStub interface, RawDo(*context.T, Request, ...rpc.CallOpt) ([]byte, error)
+pkg http, type HttpClientStub interface, unexported methods
+pkg http, type HttpServerMethods interface { RawDo }
+pkg http, type HttpServerMethods interface, RawDo(*context.T, rpc.ServerCall, Request) ([]byte, error)
+pkg http, type HttpServerStub interface, Describe__() []rpc.InterfaceDesc
+pkg http, type HttpServerStub interface, unexported methods
+pkg http, type HttpServerStubMethods HttpServerMethods
+pkg http, type Request struct
+pkg http, type Request struct, Body []byte
+pkg http, type Request struct, Close bool
+pkg http, type Request struct, ContentLength int64
+pkg http, type Request struct, Form map[string][]string
+pkg http, type Request struct, Header map[string][]string
+pkg http, type Request struct, Host string
+pkg http, type Request struct, Method string
+pkg http, type Request struct, PostForm map[string][]string
+pkg http, type Request struct, Proto string
+pkg http, type Request struct, ProtoMajor int16
+pkg http, type Request struct, ProtoMinor int16
+pkg http, type Request struct, RemoteAddr string
+pkg http, type Request struct, RequestUri string
+pkg http, type Request struct, Trailer map[string][]string
+pkg http, type Request struct, TransferEncoding []string
+pkg http, type Request struct, Url Url
+pkg http, type Url struct
+pkg http, type Url struct, Fragment string
+pkg http, type Url struct, Host string
+pkg http, type Url struct, Opaque string
+pkg http, type Url struct, Path string
+pkg http, type Url struct, RawPath string
+pkg http, type Url struct, RawQuery string
+pkg http, type Url struct, Scheme string
+pkg http, var HttpDesc rpc.InterfaceDesc
diff --git a/services/http/http.vdl b/services/http/http.vdl
new file mode 100644
index 0000000..7247656
--- /dev/null
+++ b/services/http/http.vdl
@@ -0,0 +1,47 @@
+// Copyright 2016 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package HTTP defines an interface to send a http.Request from a client to a
+// Vanadium server. This code is Go-specific since it is only used internally
+// by Vanadium.
+package http
+
+// Url represents a url.URL struct.
+// The User field is skipped since it is a struct with only unexported fields.
+type Url struct {
+ Scheme string
+ Opaque string
+ Host string
+ Path string
+ RawPath string
+ RawQuery string
+ Fragment string
+}
+
+// Request represents the http.Request struct. The MultipartForm field is
+// skipped since the docs indicate that it is ignored by clients in favor of
+// the Body field.
+type Request struct {
+ Method string
+ Url Url
+ Proto string
+ ProtoMajor int16
+ ProtoMinor int16
+ Header map[string][]string
+ Body []byte
+ ContentLength int64
+ TransferEncoding []string
+ Close bool
+ Host string
+ Form map[string][]string
+ PostForm map[string][]string
+ Trailer map[string][]string
+ RemoteAddr string
+ RequestUri string
+}
+
+type Http interface {
+ // RawDo returns the server's response to req.
+ RawDo(req Request) (data []byte | error)
+}
\ No newline at end of file
diff --git a/services/http/http.vdl.go b/services/http/http.vdl.go
new file mode 100644
index 0000000..538d667
--- /dev/null
+++ b/services/http/http.vdl.go
@@ -0,0 +1,709 @@
+// Copyright 2016 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file was auto-generated by the vanadium vdl tool.
+// Package: http
+
+// Package HTTP defines an interface to send a http.Request from a client to a
+// Vanadium server. This code is Go-specific since it is only used internally
+// by Vanadium.
+package http
+
+import (
+ "v.io/v23"
+ "v.io/v23/context"
+ "v.io/v23/rpc"
+ "v.io/v23/vdl"
+)
+
+var _ = __VDLInit() // Must be first; see __VDLInit comments for details.
+
+//////////////////////////////////////////////////
+// Type definitions
+
+// Url represents a url.URL struct.
+// The User field is skipped since it is a struct with only unexported fields.
+type Url struct {
+ Scheme string
+ Opaque string
+ Host string
+ Path string
+ RawPath string
+ RawQuery string
+ Fragment string
+}
+
+func (Url) __VDLReflect(struct {
+ Name string `vdl:"v.io/v23/services/http.Url"`
+}) {
+}
+
+func (x Url) VDLIsZero() bool {
+ return x == Url{}
+}
+
+func (x Url) VDLWrite(enc vdl.Encoder) error {
+ if err := enc.StartValue(__VDLType_struct_1); err != nil {
+ return err
+ }
+ if x.Scheme != "" {
+ if err := enc.NextFieldValueString(0, vdl.StringType, x.Scheme); err != nil {
+ return err
+ }
+ }
+ if x.Opaque != "" {
+ if err := enc.NextFieldValueString(1, vdl.StringType, x.Opaque); err != nil {
+ return err
+ }
+ }
+ if x.Host != "" {
+ if err := enc.NextFieldValueString(2, vdl.StringType, x.Host); err != nil {
+ return err
+ }
+ }
+ if x.Path != "" {
+ if err := enc.NextFieldValueString(3, vdl.StringType, x.Path); err != nil {
+ return err
+ }
+ }
+ if x.RawPath != "" {
+ if err := enc.NextFieldValueString(4, vdl.StringType, x.RawPath); err != nil {
+ return err
+ }
+ }
+ if x.RawQuery != "" {
+ if err := enc.NextFieldValueString(5, vdl.StringType, x.RawQuery); err != nil {
+ return err
+ }
+ }
+ if x.Fragment != "" {
+ if err := enc.NextFieldValueString(6, vdl.StringType, x.Fragment); err != nil {
+ return err
+ }
+ }
+ if err := enc.NextField(-1); err != nil {
+ return err
+ }
+ return enc.FinishValue()
+}
+
+func (x *Url) VDLRead(dec vdl.Decoder) error {
+ *x = Url{}
+ if err := dec.StartValue(__VDLType_struct_1); err != nil {
+ return err
+ }
+ decType := dec.Type()
+ for {
+ index, err := dec.NextField()
+ switch {
+ case err != nil:
+ return err
+ case index == -1:
+ return dec.FinishValue()
+ }
+ if decType != __VDLType_struct_1 {
+ index = __VDLType_struct_1.FieldIndexByName(decType.Field(index).Name)
+ if index == -1 {
+ if err := dec.SkipValue(); err != nil {
+ return err
+ }
+ continue
+ }
+ }
+ switch index {
+ case 0:
+ switch value, err := dec.ReadValueString(); {
+ case err != nil:
+ return err
+ default:
+ x.Scheme = value
+ }
+ case 1:
+ switch value, err := dec.ReadValueString(); {
+ case err != nil:
+ return err
+ default:
+ x.Opaque = value
+ }
+ case 2:
+ switch value, err := dec.ReadValueString(); {
+ case err != nil:
+ return err
+ default:
+ x.Host = value
+ }
+ case 3:
+ switch value, err := dec.ReadValueString(); {
+ case err != nil:
+ return err
+ default:
+ x.Path = value
+ }
+ case 4:
+ switch value, err := dec.ReadValueString(); {
+ case err != nil:
+ return err
+ default:
+ x.RawPath = value
+ }
+ case 5:
+ switch value, err := dec.ReadValueString(); {
+ case err != nil:
+ return err
+ default:
+ x.RawQuery = value
+ }
+ case 6:
+ switch value, err := dec.ReadValueString(); {
+ case err != nil:
+ return err
+ default:
+ x.Fragment = value
+ }
+ }
+ }
+}
+
+// Request represents the http.Request struct. The MultipartForm field is
+// skipped since the docs indicate that it is ignored by clients in favor of
+// the Body field.
+type Request struct {
+ Method string
+ Url Url
+ Proto string
+ ProtoMajor int16
+ ProtoMinor int16
+ Header map[string][]string
+ Body []byte
+ ContentLength int64
+ TransferEncoding []string
+ Close bool
+ Host string
+ Form map[string][]string
+ PostForm map[string][]string
+ Trailer map[string][]string
+ RemoteAddr string
+ RequestUri string
+}
+
+func (Request) __VDLReflect(struct {
+ Name string `vdl:"v.io/v23/services/http.Request"`
+}) {
+}
+
+func (x Request) VDLIsZero() bool {
+ if x.Method != "" {
+ return false
+ }
+ if x.Url != (Url{}) {
+ return false
+ }
+ if x.Proto != "" {
+ return false
+ }
+ if x.ProtoMajor != 0 {
+ return false
+ }
+ if x.ProtoMinor != 0 {
+ return false
+ }
+ if len(x.Header) != 0 {
+ return false
+ }
+ if len(x.Body) != 0 {
+ return false
+ }
+ if x.ContentLength != 0 {
+ return false
+ }
+ if len(x.TransferEncoding) != 0 {
+ return false
+ }
+ if x.Close {
+ return false
+ }
+ if x.Host != "" {
+ return false
+ }
+ if len(x.Form) != 0 {
+ return false
+ }
+ if len(x.PostForm) != 0 {
+ return false
+ }
+ if len(x.Trailer) != 0 {
+ return false
+ }
+ if x.RemoteAddr != "" {
+ return false
+ }
+ if x.RequestUri != "" {
+ return false
+ }
+ return true
+}
+
+func (x Request) VDLWrite(enc vdl.Encoder) error {
+ if err := enc.StartValue(__VDLType_struct_2); err != nil {
+ return err
+ }
+ if x.Method != "" {
+ if err := enc.NextFieldValueString(0, vdl.StringType, x.Method); err != nil {
+ return err
+ }
+ }
+ if x.Url != (Url{}) {
+ if err := enc.NextField(1); err != nil {
+ return err
+ }
+ if err := x.Url.VDLWrite(enc); err != nil {
+ return err
+ }
+ }
+ if x.Proto != "" {
+ if err := enc.NextFieldValueString(2, vdl.StringType, x.Proto); err != nil {
+ return err
+ }
+ }
+ if x.ProtoMajor != 0 {
+ if err := enc.NextFieldValueInt(3, vdl.Int16Type, int64(x.ProtoMajor)); err != nil {
+ return err
+ }
+ }
+ if x.ProtoMinor != 0 {
+ if err := enc.NextFieldValueInt(4, vdl.Int16Type, int64(x.ProtoMinor)); err != nil {
+ return err
+ }
+ }
+ if len(x.Header) != 0 {
+ if err := enc.NextField(5); err != nil {
+ return err
+ }
+ if err := __VDLWriteAnon_map_1(enc, x.Header); err != nil {
+ return err
+ }
+ }
+ if len(x.Body) != 0 {
+ if err := enc.NextFieldValueBytes(6, __VDLType_list_4, x.Body); err != nil {
+ return err
+ }
+ }
+ if x.ContentLength != 0 {
+ if err := enc.NextFieldValueInt(7, vdl.Int64Type, x.ContentLength); err != nil {
+ return err
+ }
+ }
+ if len(x.TransferEncoding) != 0 {
+ if err := enc.NextField(8); err != nil {
+ return err
+ }
+ if err := __VDLWriteAnon_list_2(enc, x.TransferEncoding); err != nil {
+ return err
+ }
+ }
+ if x.Close {
+ if err := enc.NextFieldValueBool(9, vdl.BoolType, x.Close); err != nil {
+ return err
+ }
+ }
+ if x.Host != "" {
+ if err := enc.NextFieldValueString(10, vdl.StringType, x.Host); err != nil {
+ return err
+ }
+ }
+ if len(x.Form) != 0 {
+ if err := enc.NextField(11); err != nil {
+ return err
+ }
+ if err := __VDLWriteAnon_map_1(enc, x.Form); err != nil {
+ return err
+ }
+ }
+ if len(x.PostForm) != 0 {
+ if err := enc.NextField(12); err != nil {
+ return err
+ }
+ if err := __VDLWriteAnon_map_1(enc, x.PostForm); err != nil {
+ return err
+ }
+ }
+ if len(x.Trailer) != 0 {
+ if err := enc.NextField(13); err != nil {
+ return err
+ }
+ if err := __VDLWriteAnon_map_1(enc, x.Trailer); err != nil {
+ return err
+ }
+ }
+ if x.RemoteAddr != "" {
+ if err := enc.NextFieldValueString(14, vdl.StringType, x.RemoteAddr); err != nil {
+ return err
+ }
+ }
+ if x.RequestUri != "" {
+ if err := enc.NextFieldValueString(15, vdl.StringType, x.RequestUri); err != nil {
+ return err
+ }
+ }
+ if err := enc.NextField(-1); err != nil {
+ return err
+ }
+ return enc.FinishValue()
+}
+
+func __VDLWriteAnon_map_1(enc vdl.Encoder, x map[string][]string) error {
+ if err := enc.StartValue(__VDLType_map_3); err != nil {
+ return err
+ }
+ if err := enc.SetLenHint(len(x)); err != nil {
+ return err
+ }
+ for key, elem := range x {
+ if err := enc.NextEntryValueString(vdl.StringType, key); err != nil {
+ return err
+ }
+ if err := __VDLWriteAnon_list_2(enc, elem); err != nil {
+ return err
+ }
+ }
+ if err := enc.NextEntry(true); err != nil {
+ return err
+ }
+ return enc.FinishValue()
+}
+
+func __VDLWriteAnon_list_2(enc vdl.Encoder, x []string) error {
+ if err := enc.StartValue(__VDLType_list_5); err != nil {
+ return err
+ }
+ if err := enc.SetLenHint(len(x)); err != nil {
+ return err
+ }
+ for _, elem := range x {
+ if err := enc.NextEntryValueString(vdl.StringType, elem); err != nil {
+ return err
+ }
+ }
+ if err := enc.NextEntry(true); err != nil {
+ return err
+ }
+ return enc.FinishValue()
+}
+
+func (x *Request) VDLRead(dec vdl.Decoder) error {
+ *x = Request{}
+ if err := dec.StartValue(__VDLType_struct_2); err != nil {
+ return err
+ }
+ decType := dec.Type()
+ for {
+ index, err := dec.NextField()
+ switch {
+ case err != nil:
+ return err
+ case index == -1:
+ return dec.FinishValue()
+ }
+ if decType != __VDLType_struct_2 {
+ index = __VDLType_struct_2.FieldIndexByName(decType.Field(index).Name)
+ if index == -1 {
+ if err := dec.SkipValue(); err != nil {
+ return err
+ }
+ continue
+ }
+ }
+ switch index {
+ case 0:
+ switch value, err := dec.ReadValueString(); {
+ case err != nil:
+ return err
+ default:
+ x.Method = value
+ }
+ case 1:
+ if err := x.Url.VDLRead(dec); err != nil {
+ return err
+ }
+ case 2:
+ switch value, err := dec.ReadValueString(); {
+ case err != nil:
+ return err
+ default:
+ x.Proto = value
+ }
+ case 3:
+ switch value, err := dec.ReadValueInt(16); {
+ case err != nil:
+ return err
+ default:
+ x.ProtoMajor = int16(value)
+ }
+ case 4:
+ switch value, err := dec.ReadValueInt(16); {
+ case err != nil:
+ return err
+ default:
+ x.ProtoMinor = int16(value)
+ }
+ case 5:
+ if err := __VDLReadAnon_map_1(dec, &x.Header); err != nil {
+ return err
+ }
+ case 6:
+ if err := dec.ReadValueBytes(-1, &x.Body); err != nil {
+ return err
+ }
+ case 7:
+ switch value, err := dec.ReadValueInt(64); {
+ case err != nil:
+ return err
+ default:
+ x.ContentLength = value
+ }
+ case 8:
+ if err := __VDLReadAnon_list_2(dec, &x.TransferEncoding); err != nil {
+ return err
+ }
+ case 9:
+ switch value, err := dec.ReadValueBool(); {
+ case err != nil:
+ return err
+ default:
+ x.Close = value
+ }
+ case 10:
+ switch value, err := dec.ReadValueString(); {
+ case err != nil:
+ return err
+ default:
+ x.Host = value
+ }
+ case 11:
+ if err := __VDLReadAnon_map_1(dec, &x.Form); err != nil {
+ return err
+ }
+ case 12:
+ if err := __VDLReadAnon_map_1(dec, &x.PostForm); err != nil {
+ return err
+ }
+ case 13:
+ if err := __VDLReadAnon_map_1(dec, &x.Trailer); err != nil {
+ return err
+ }
+ case 14:
+ switch value, err := dec.ReadValueString(); {
+ case err != nil:
+ return err
+ default:
+ x.RemoteAddr = value
+ }
+ case 15:
+ switch value, err := dec.ReadValueString(); {
+ case err != nil:
+ return err
+ default:
+ x.RequestUri = value
+ }
+ }
+ }
+}
+
+func __VDLReadAnon_map_1(dec vdl.Decoder, x *map[string][]string) error {
+ if err := dec.StartValue(__VDLType_map_3); err != nil {
+ return err
+ }
+ var tmpMap map[string][]string
+ if len := dec.LenHint(); len > 0 {
+ tmpMap = make(map[string][]string, len)
+ }
+ for {
+ switch done, key, err := dec.NextEntryValueString(); {
+ case err != nil:
+ return err
+ case done:
+ *x = tmpMap
+ return dec.FinishValue()
+ default:
+ var elem []string
+ if err := __VDLReadAnon_list_2(dec, &elem); err != nil {
+ return err
+ }
+ if tmpMap == nil {
+ tmpMap = make(map[string][]string)
+ }
+ tmpMap[key] = elem
+ }
+ }
+}
+
+func __VDLReadAnon_list_2(dec vdl.Decoder, x *[]string) error {
+ if err := dec.StartValue(__VDLType_list_5); err != nil {
+ return err
+ }
+ if len := dec.LenHint(); len > 0 {
+ *x = make([]string, 0, len)
+ } else {
+ *x = nil
+ }
+ for {
+ switch done, elem, err := dec.NextEntryValueString(); {
+ case err != nil:
+ return err
+ case done:
+ return dec.FinishValue()
+ default:
+ *x = append(*x, elem)
+ }
+ }
+}
+
+//////////////////////////////////////////////////
+// Interface definitions
+
+// HttpClientMethods is the client interface
+// containing Http methods.
+type HttpClientMethods interface {
+ // RawDo returns the server's response to req.
+ RawDo(_ *context.T, req Request, _ ...rpc.CallOpt) (data []byte, _ error)
+}
+
+// HttpClientStub adds universal methods to HttpClientMethods.
+type HttpClientStub interface {
+ HttpClientMethods
+ rpc.UniversalServiceMethods
+}
+
+// HttpClient returns a client stub for Http.
+func HttpClient(name string) HttpClientStub {
+ return implHttpClientStub{name}
+}
+
+type implHttpClientStub struct {
+ name string
+}
+
+func (c implHttpClientStub) RawDo(ctx *context.T, i0 Request, opts ...rpc.CallOpt) (o0 []byte, err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "RawDo", []interface{}{i0}, []interface{}{&o0}, opts...)
+ return
+}
+
+// HttpServerMethods is the interface a server writer
+// implements for Http.
+type HttpServerMethods interface {
+ // RawDo returns the server's response to req.
+ RawDo(_ *context.T, _ rpc.ServerCall, req Request) (data []byte, _ error)
+}
+
+// HttpServerStubMethods is the server interface containing
+// Http methods, as expected by rpc.Server.
+// There is no difference between this interface and HttpServerMethods
+// since there are no streaming methods.
+type HttpServerStubMethods HttpServerMethods
+
+// HttpServerStub adds universal methods to HttpServerStubMethods.
+type HttpServerStub interface {
+ HttpServerStubMethods
+ // Describe the Http interfaces.
+ Describe__() []rpc.InterfaceDesc
+}
+
+// HttpServer returns a server stub for Http.
+// It converts an implementation of HttpServerMethods into
+// an object that may be used by rpc.Server.
+func HttpServer(impl HttpServerMethods) HttpServerStub {
+ stub := implHttpServerStub{
+ impl: impl,
+ }
+ // Initialize GlobState; always check the stub itself first, to handle the
+ // case where the user has the Glob method defined in their VDL source.
+ if gs := rpc.NewGlobState(stub); gs != nil {
+ stub.gs = gs
+ } else if gs := rpc.NewGlobState(impl); gs != nil {
+ stub.gs = gs
+ }
+ return stub
+}
+
+type implHttpServerStub struct {
+ impl HttpServerMethods
+ gs *rpc.GlobState
+}
+
+func (s implHttpServerStub) RawDo(ctx *context.T, call rpc.ServerCall, i0 Request) ([]byte, error) {
+ return s.impl.RawDo(ctx, call, i0)
+}
+
+func (s implHttpServerStub) Globber() *rpc.GlobState {
+ return s.gs
+}
+
+func (s implHttpServerStub) Describe__() []rpc.InterfaceDesc {
+ return []rpc.InterfaceDesc{HttpDesc}
+}
+
+// HttpDesc describes the Http interface.
+var HttpDesc rpc.InterfaceDesc = descHttp
+
+// descHttp hides the desc to keep godoc clean.
+var descHttp = rpc.InterfaceDesc{
+ Name: "Http",
+ PkgPath: "v.io/v23/services/http",
+ Methods: []rpc.MethodDesc{
+ {
+ Name: "RawDo",
+ Doc: "// RawDo returns the server's response to req.",
+ InArgs: []rpc.ArgDesc{
+ {"req", ``}, // Request
+ },
+ OutArgs: []rpc.ArgDesc{
+ {"data", ``}, // []byte
+ },
+ },
+ },
+}
+
+// Hold type definitions in package-level variables, for better performance.
+var (
+ __VDLType_struct_1 *vdl.Type
+ __VDLType_struct_2 *vdl.Type
+ __VDLType_map_3 *vdl.Type
+ __VDLType_list_4 *vdl.Type
+ __VDLType_list_5 *vdl.Type
+)
+
+var __VDLInitCalled bool
+
+// __VDLInit performs vdl initialization. It is safe to call multiple times.
+// If you have an init ordering issue, just insert the following line verbatim
+// into your source files in this package, right after the "package foo" clause:
+//
+// var _ = __VDLInit()
+//
+// The purpose of this function is to ensure that vdl initialization occurs in
+// the right order, and very early in the init sequence. In particular, vdl
+// registration and package variable initialization needs to occur before
+// functions like vdl.TypeOf will work properly.
+//
+// This function returns a dummy value, so that it can be used to initialize the
+// first var in the file, to take advantage of Go's defined init order.
+func __VDLInit() struct{} {
+ if __VDLInitCalled {
+ return struct{}{}
+ }
+ __VDLInitCalled = true
+
+ // Register types.
+ vdl.Register((*Url)(nil))
+ vdl.Register((*Request)(nil))
+
+ // Initialize type definitions.
+ __VDLType_struct_1 = vdl.TypeOf((*Url)(nil)).Elem()
+ __VDLType_struct_2 = vdl.TypeOf((*Request)(nil)).Elem()
+ __VDLType_map_3 = vdl.TypeOf((*map[string][]string)(nil))
+ __VDLType_list_4 = vdl.TypeOf((*[]byte)(nil))
+ __VDLType_list_5 = vdl.TypeOf((*[]string)(nil))
+
+ return struct{}{}
+}