| // Copyright 2015 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: app |
| |
| // The app package contains the struct that keeps per javascript app state and handles translating |
| // javascript requests to vanadium requests and vice versa. |
| package app |
| |
| import ( |
| "fmt" |
| "reflect" |
| "v.io/v23" |
| "v.io/v23/context" |
| "v.io/v23/rpc" |
| "v.io/v23/security" |
| "v.io/v23/uniqueid" |
| "v.io/v23/vdl" |
| "v.io/v23/vdl/vdlconv" |
| "v.io/v23/vdlroot/signature" |
| "v.io/v23/vdlroot/time" |
| "v.io/v23/verror" |
| "v.io/v23/vom" |
| "v.io/v23/vtrace" |
| "v.io/x/ref/services/wspr/internal/principal" |
| "v.io/x/ref/services/wspr/internal/rpc/server" |
| ) |
| |
| var _ = __VDLInit() // Must be first; see __VDLInit comments for details. |
| |
| ////////////////////////////////////////////////// |
| // Type definitions |
| |
| type GranterHandle int32 |
| |
| func (GranterHandle) __VDLReflect(struct { |
| Name string `vdl:"v.io/x/ref/services/wspr/internal/app.GranterHandle"` |
| }) { |
| } |
| |
| func (m *GranterHandle) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| if err := t.FromInt(int64((*m)), tt); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (m *GranterHandle) MakeVDLTarget() vdl.Target { |
| return &GranterHandleTarget{Value: m} |
| } |
| |
| type GranterHandleTarget struct { |
| Value *GranterHandle |
| vdl.TargetBase |
| } |
| |
| func (t *GranterHandleTarget) FromUint(src uint64, tt *vdl.Type) error { |
| |
| val, err := vdlconv.Uint64ToInt32(src) |
| if err != nil { |
| return err |
| } |
| *t.Value = GranterHandle(val) |
| |
| return nil |
| } |
| func (t *GranterHandleTarget) FromInt(src int64, tt *vdl.Type) error { |
| |
| val, err := vdlconv.Int64ToInt32(src) |
| if err != nil { |
| return err |
| } |
| *t.Value = GranterHandle(val) |
| |
| return nil |
| } |
| func (t *GranterHandleTarget) FromFloat(src float64, tt *vdl.Type) error { |
| |
| val, err := vdlconv.Float64ToInt32(src) |
| if err != nil { |
| return err |
| } |
| *t.Value = GranterHandle(val) |
| |
| return nil |
| } |
| |
| type ( |
| // RpcCallOption represents any single field of the RpcCallOption union type. |
| RpcCallOption interface { |
| // Index returns the field index. |
| Index() int |
| // Interface returns the field value as an interface. |
| Interface() interface{} |
| // Name returns the field name. |
| Name() string |
| // __VDLReflect describes the RpcCallOption union type. |
| __VDLReflect(__RpcCallOptionReflect) |
| FillVDLTarget(vdl.Target, *vdl.Type) error |
| } |
| // RpcCallOptionAllowedServersPolicy represents field AllowedServersPolicy of the RpcCallOption union type. |
| RpcCallOptionAllowedServersPolicy struct{ Value []security.BlessingPattern } |
| // RpcCallOptionGranter represents field Granter of the RpcCallOption union type. |
| RpcCallOptionGranter struct{ Value GranterHandle } |
| // __RpcCallOptionReflect describes the RpcCallOption union type. |
| __RpcCallOptionReflect struct { |
| Name string `vdl:"v.io/x/ref/services/wspr/internal/app.RpcCallOption"` |
| Type RpcCallOption |
| UnionTargetFactory rpcCallOptionTargetFactory |
| Union struct { |
| AllowedServersPolicy RpcCallOptionAllowedServersPolicy |
| Granter RpcCallOptionGranter |
| } |
| } |
| ) |
| |
| func (x RpcCallOptionAllowedServersPolicy) Index() int { return 0 } |
| func (x RpcCallOptionAllowedServersPolicy) Interface() interface{} { return x.Value } |
| func (x RpcCallOptionAllowedServersPolicy) Name() string { return "AllowedServersPolicy" } |
| func (x RpcCallOptionAllowedServersPolicy) __VDLReflect(__RpcCallOptionReflect) {} |
| |
| func (m RpcCallOptionAllowedServersPolicy) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("AllowedServersPolicy") |
| if err != nil { |
| return err |
| } |
| |
| listTarget4, err := fieldTarget3.StartList(tt.NonOptional().Field(0).Type, len(m.Value)) |
| if err != nil { |
| return err |
| } |
| for i, elem6 := range m.Value { |
| elemTarget5, err := listTarget4.StartElem(i) |
| if err != nil { |
| return err |
| } |
| |
| if err := elem6.FillVDLTarget(elemTarget5, tt.NonOptional().Field(0).Type.Elem()); err != nil { |
| return err |
| } |
| if err := listTarget4.FinishElem(elemTarget5); err != nil { |
| return err |
| } |
| } |
| if err := fieldTarget3.FinishList(listTarget4); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil { |
| return err |
| } |
| if err := t.FinishFields(fieldsTarget1); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func (m RpcCallOptionAllowedServersPolicy) MakeVDLTarget() vdl.Target { |
| return nil |
| } |
| |
| func (x RpcCallOptionGranter) Index() int { return 1 } |
| func (x RpcCallOptionGranter) Interface() interface{} { return x.Value } |
| func (x RpcCallOptionGranter) Name() string { return "Granter" } |
| func (x RpcCallOptionGranter) __VDLReflect(__RpcCallOptionReflect) {} |
| |
| func (m RpcCallOptionGranter) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Granter") |
| if err != nil { |
| return err |
| } |
| |
| if err := m.Value.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(1).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil { |
| return err |
| } |
| if err := t.FinishFields(fieldsTarget1); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func (m RpcCallOptionGranter) MakeVDLTarget() vdl.Target { |
| return nil |
| } |
| |
| type RpcCallOptionTarget struct { |
| Value *RpcCallOption |
| fieldName string |
| |
| vdl.TargetBase |
| vdl.FieldsTargetBase |
| } |
| |
| func (t *RpcCallOptionTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) { |
| if ttWant := vdl.TypeOf((*RpcCallOption)(nil)); !vdl.Compatible(tt, ttWant) { |
| return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant) |
| } |
| |
| return t, nil |
| } |
| func (t *RpcCallOptionTarget) StartField(name string) (key, field vdl.Target, _ error) { |
| t.fieldName = name |
| switch name { |
| case "AllowedServersPolicy": |
| val := []security.BlessingPattern(nil) |
| return nil, &__VDLTarget1_list{Value: &val}, nil |
| case "Granter": |
| val := GranterHandle(0) |
| return nil, &GranterHandleTarget{Value: &val}, nil |
| default: |
| return nil, nil, fmt.Errorf("field %s not in union v.io/x/ref/services/wspr/internal/app.RpcCallOption", name) |
| } |
| } |
| func (t *RpcCallOptionTarget) FinishField(_, fieldTarget vdl.Target) error { |
| switch t.fieldName { |
| case "AllowedServersPolicy": |
| *t.Value = RpcCallOptionAllowedServersPolicy{*(fieldTarget.(*__VDLTarget1_list)).Value} |
| case "Granter": |
| *t.Value = RpcCallOptionGranter{*(fieldTarget.(*GranterHandleTarget)).Value} |
| } |
| return nil |
| } |
| func (t *RpcCallOptionTarget) FinishFields(_ vdl.FieldsTarget) error { |
| |
| return nil |
| } |
| |
| type rpcCallOptionTargetFactory struct{} |
| |
| func (t rpcCallOptionTargetFactory) VDLMakeUnionTarget(union interface{}) (vdl.Target, error) { |
| if typedUnion, ok := union.(*RpcCallOption); ok { |
| return &RpcCallOptionTarget{Value: typedUnion}, nil |
| } |
| return nil, fmt.Errorf("got %T, want *RpcCallOption", union) |
| } |
| |
| // []security.BlessingPattern |
| type __VDLTarget1_list struct { |
| Value *[]security.BlessingPattern |
| elemTarget security.BlessingPatternTarget |
| vdl.TargetBase |
| vdl.ListTargetBase |
| } |
| |
| func (t *__VDLTarget1_list) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) { |
| |
| if ttWant := vdl.TypeOf((*[]security.BlessingPattern)(nil)); !vdl.Compatible(tt, ttWant) { |
| return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant) |
| } |
| if cap(*t.Value) < len { |
| *t.Value = make([]security.BlessingPattern, len) |
| } else { |
| *t.Value = (*t.Value)[:len] |
| } |
| return t, nil |
| } |
| func (t *__VDLTarget1_list) StartElem(index int) (elem vdl.Target, _ error) { |
| t.elemTarget.Value = &(*t.Value)[index] |
| target, err := &t.elemTarget, error(nil) |
| return target, err |
| } |
| func (t *__VDLTarget1_list) FinishElem(elem vdl.Target) error { |
| return nil |
| } |
| func (t *__VDLTarget1_list) FinishList(elem vdl.ListTarget) error { |
| |
| return nil |
| } |
| |
| type RpcRequest struct { |
| Name string |
| Method string |
| NumInArgs int32 |
| NumOutArgs int32 |
| IsStreaming bool |
| Deadline time.Deadline |
| TraceRequest vtrace.Request |
| Context server.Context |
| CallOptions []RpcCallOption |
| } |
| |
| func (RpcRequest) __VDLReflect(struct { |
| Name string `vdl:"v.io/x/ref/services/wspr/internal/app.RpcRequest"` |
| }) { |
| } |
| |
| func (m *RpcRequest) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| var4 := (m.Name == "") |
| if var4 { |
| if err := fieldsTarget1.ZeroField("Name"); err != nil && err != vdl.ErrFieldNoExist { |
| return err |
| } |
| } else { |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name") |
| if err != vdl.ErrFieldNoExist { |
| if err != nil { |
| return err |
| } |
| if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil { |
| return err |
| } |
| } |
| } |
| var7 := (m.Method == "") |
| if var7 { |
| if err := fieldsTarget1.ZeroField("Method"); err != nil && err != vdl.ErrFieldNoExist { |
| return err |
| } |
| } else { |
| keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Method") |
| if err != vdl.ErrFieldNoExist { |
| if err != nil { |
| return err |
| } |
| if err := fieldTarget6.FromString(string(m.Method), tt.NonOptional().Field(1).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil { |
| return err |
| } |
| } |
| } |
| var10 := (m.NumInArgs == int32(0)) |
| if var10 { |
| if err := fieldsTarget1.ZeroField("NumInArgs"); err != nil && err != vdl.ErrFieldNoExist { |
| return err |
| } |
| } else { |
| keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("NumInArgs") |
| if err != vdl.ErrFieldNoExist { |
| if err != nil { |
| return err |
| } |
| if err := fieldTarget9.FromInt(int64(m.NumInArgs), tt.NonOptional().Field(2).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil { |
| return err |
| } |
| } |
| } |
| var13 := (m.NumOutArgs == int32(0)) |
| if var13 { |
| if err := fieldsTarget1.ZeroField("NumOutArgs"); err != nil && err != vdl.ErrFieldNoExist { |
| return err |
| } |
| } else { |
| keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("NumOutArgs") |
| if err != vdl.ErrFieldNoExist { |
| if err != nil { |
| return err |
| } |
| if err := fieldTarget12.FromInt(int64(m.NumOutArgs), tt.NonOptional().Field(3).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil { |
| return err |
| } |
| } |
| } |
| var16 := (m.IsStreaming == false) |
| if var16 { |
| if err := fieldsTarget1.ZeroField("IsStreaming"); err != nil && err != vdl.ErrFieldNoExist { |
| return err |
| } |
| } else { |
| keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("IsStreaming") |
| if err != vdl.ErrFieldNoExist { |
| if err != nil { |
| return err |
| } |
| if err := fieldTarget15.FromBool(bool(m.IsStreaming), tt.NonOptional().Field(4).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget14, fieldTarget15); err != nil { |
| return err |
| } |
| } |
| } |
| var wireValue17 time.WireDeadline |
| if err := time.WireDeadlineFromNative(&wireValue17, m.Deadline); err != nil { |
| return err |
| } |
| |
| var20 := (wireValue17 == time.WireDeadline{}) |
| if var20 { |
| if err := fieldsTarget1.ZeroField("Deadline"); err != nil && err != vdl.ErrFieldNoExist { |
| return err |
| } |
| } else { |
| keyTarget18, fieldTarget19, err := fieldsTarget1.StartField("Deadline") |
| if err != vdl.ErrFieldNoExist { |
| if err != nil { |
| return err |
| } |
| |
| if err := wireValue17.FillVDLTarget(fieldTarget19, tt.NonOptional().Field(5).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget18, fieldTarget19); err != nil { |
| return err |
| } |
| } |
| } |
| var23 := (m.TraceRequest == vtrace.Request{}) |
| if var23 { |
| if err := fieldsTarget1.ZeroField("TraceRequest"); err != nil && err != vdl.ErrFieldNoExist { |
| return err |
| } |
| } else { |
| keyTarget21, fieldTarget22, err := fieldsTarget1.StartField("TraceRequest") |
| if err != vdl.ErrFieldNoExist { |
| if err != nil { |
| return err |
| } |
| |
| if err := m.TraceRequest.FillVDLTarget(fieldTarget22, tt.NonOptional().Field(6).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget21, fieldTarget22); err != nil { |
| return err |
| } |
| } |
| } |
| var26 := (m.Context == server.Context{}) |
| if var26 { |
| if err := fieldsTarget1.ZeroField("Context"); err != nil && err != vdl.ErrFieldNoExist { |
| return err |
| } |
| } else { |
| keyTarget24, fieldTarget25, err := fieldsTarget1.StartField("Context") |
| if err != vdl.ErrFieldNoExist { |
| if err != nil { |
| return err |
| } |
| |
| if err := m.Context.FillVDLTarget(fieldTarget25, tt.NonOptional().Field(7).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget24, fieldTarget25); err != nil { |
| return err |
| } |
| } |
| } |
| var var29 bool |
| if len(m.CallOptions) == 0 { |
| var29 = true |
| } |
| if var29 { |
| if err := fieldsTarget1.ZeroField("CallOptions"); err != nil && err != vdl.ErrFieldNoExist { |
| return err |
| } |
| } else { |
| keyTarget27, fieldTarget28, err := fieldsTarget1.StartField("CallOptions") |
| if err != vdl.ErrFieldNoExist { |
| if err != nil { |
| return err |
| } |
| |
| listTarget30, err := fieldTarget28.StartList(tt.NonOptional().Field(8).Type, len(m.CallOptions)) |
| if err != nil { |
| return err |
| } |
| for i, elem32 := range m.CallOptions { |
| elemTarget31, err := listTarget30.StartElem(i) |
| if err != nil { |
| return err |
| } |
| |
| unionValue33 := elem32 |
| if unionValue33 == nil { |
| unionValue33 = RpcCallOptionAllowedServersPolicy{} |
| } |
| if err := unionValue33.FillVDLTarget(elemTarget31, tt.NonOptional().Field(8).Type.Elem()); err != nil { |
| return err |
| } |
| if err := listTarget30.FinishElem(elemTarget31); err != nil { |
| return err |
| } |
| } |
| if err := fieldTarget28.FinishList(listTarget30); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget27, fieldTarget28); err != nil { |
| return err |
| } |
| } |
| } |
| if err := t.FinishFields(fieldsTarget1); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (m *RpcRequest) MakeVDLTarget() vdl.Target { |
| return &RpcRequestTarget{Value: m} |
| } |
| |
| type RpcRequestTarget struct { |
| Value *RpcRequest |
| nameTarget vdl.StringTarget |
| methodTarget vdl.StringTarget |
| numInArgsTarget vdl.Int32Target |
| numOutArgsTarget vdl.Int32Target |
| isStreamingTarget vdl.BoolTarget |
| deadlineTarget time.WireDeadlineTarget |
| traceRequestTarget vtrace.RequestTarget |
| contextTarget server.ContextTarget |
| callOptionsTarget __VDLTarget2_list |
| vdl.TargetBase |
| vdl.FieldsTargetBase |
| } |
| |
| func (t *RpcRequestTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) { |
| |
| if ttWant := vdl.TypeOf((*RpcRequest)(nil)).Elem(); !vdl.Compatible(tt, ttWant) { |
| return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant) |
| } |
| return t, nil |
| } |
| func (t *RpcRequestTarget) StartField(name string) (key, field vdl.Target, _ error) { |
| switch name { |
| case "Name": |
| t.nameTarget.Value = &t.Value.Name |
| target, err := &t.nameTarget, error(nil) |
| return nil, target, err |
| case "Method": |
| t.methodTarget.Value = &t.Value.Method |
| target, err := &t.methodTarget, error(nil) |
| return nil, target, err |
| case "NumInArgs": |
| t.numInArgsTarget.Value = &t.Value.NumInArgs |
| target, err := &t.numInArgsTarget, error(nil) |
| return nil, target, err |
| case "NumOutArgs": |
| t.numOutArgsTarget.Value = &t.Value.NumOutArgs |
| target, err := &t.numOutArgsTarget, error(nil) |
| return nil, target, err |
| case "IsStreaming": |
| t.isStreamingTarget.Value = &t.Value.IsStreaming |
| target, err := &t.isStreamingTarget, error(nil) |
| return nil, target, err |
| case "Deadline": |
| t.deadlineTarget.Value = &t.Value.Deadline |
| target, err := &t.deadlineTarget, error(nil) |
| return nil, target, err |
| case "TraceRequest": |
| t.traceRequestTarget.Value = &t.Value.TraceRequest |
| target, err := &t.traceRequestTarget, error(nil) |
| return nil, target, err |
| case "Context": |
| t.contextTarget.Value = &t.Value.Context |
| target, err := &t.contextTarget, error(nil) |
| return nil, target, err |
| case "CallOptions": |
| t.callOptionsTarget.Value = &t.Value.CallOptions |
| target, err := &t.callOptionsTarget, error(nil) |
| return nil, target, err |
| default: |
| return nil, nil, fmt.Errorf("field %s not in struct v.io/x/ref/services/wspr/internal/app.RpcRequest", name) |
| } |
| } |
| func (t *RpcRequestTarget) FinishField(_, _ vdl.Target) error { |
| return nil |
| } |
| func (t *RpcRequestTarget) ZeroField(name string) error { |
| switch name { |
| case "Name": |
| t.Value.Name = "" |
| return nil |
| case "Method": |
| t.Value.Method = "" |
| return nil |
| case "NumInArgs": |
| t.Value.NumInArgs = int32(0) |
| return nil |
| case "NumOutArgs": |
| t.Value.NumOutArgs = int32(0) |
| return nil |
| case "IsStreaming": |
| t.Value.IsStreaming = false |
| return nil |
| case "Deadline": |
| t.Value.Deadline = func() time.Deadline { |
| var native time.Deadline |
| if err := vdl.Convert(&native, time.WireDeadline{}); err != nil { |
| panic(err) |
| } |
| return native |
| }() |
| return nil |
| case "TraceRequest": |
| t.Value.TraceRequest = vtrace.Request{} |
| return nil |
| case "Context": |
| t.Value.Context = server.Context{} |
| return nil |
| case "CallOptions": |
| t.Value.CallOptions = []RpcCallOption(nil) |
| return nil |
| default: |
| return fmt.Errorf("field %s not in struct v.io/x/ref/services/wspr/internal/app.RpcRequest", name) |
| } |
| } |
| func (t *RpcRequestTarget) FinishFields(_ vdl.FieldsTarget) error { |
| |
| return nil |
| } |
| |
| // []RpcCallOption |
| type __VDLTarget2_list struct { |
| Value *[]RpcCallOption |
| elemTarget RpcCallOptionTarget |
| vdl.TargetBase |
| vdl.ListTargetBase |
| } |
| |
| func (t *__VDLTarget2_list) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) { |
| |
| if ttWant := vdl.TypeOf((*[]RpcCallOption)(nil)); !vdl.Compatible(tt, ttWant) { |
| return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant) |
| } |
| if cap(*t.Value) < len { |
| *t.Value = make([]RpcCallOption, len) |
| } else { |
| *t.Value = (*t.Value)[:len] |
| } |
| return t, nil |
| } |
| func (t *__VDLTarget2_list) StartElem(index int) (elem vdl.Target, _ error) { |
| t.elemTarget.Value = &(*t.Value)[index] |
| target, err := &t.elemTarget, error(nil) |
| return target, err |
| } |
| func (t *__VDLTarget2_list) FinishElem(elem vdl.Target) error { |
| return nil |
| } |
| func (t *__VDLTarget2_list) FinishList(elem vdl.ListTarget) error { |
| |
| return nil |
| } |
| |
| type ( |
| // RpcServerOption represents any single field of the RpcServerOption union type. |
| RpcServerOption interface { |
| // Index returns the field index. |
| Index() int |
| // Interface returns the field value as an interface. |
| Interface() interface{} |
| // Name returns the field name. |
| Name() string |
| // __VDLReflect describes the RpcServerOption union type. |
| __VDLReflect(__RpcServerOptionReflect) |
| FillVDLTarget(vdl.Target, *vdl.Type) error |
| } |
| // RpcServerOptionIsLeaf represents field IsLeaf of the RpcServerOption union type. |
| RpcServerOptionIsLeaf struct{ Value bool } |
| // RpcServerOptionServesMountTable represents field ServesMountTable of the RpcServerOption union type. |
| RpcServerOptionServesMountTable struct{ Value bool } |
| // __RpcServerOptionReflect describes the RpcServerOption union type. |
| __RpcServerOptionReflect struct { |
| Name string `vdl:"v.io/x/ref/services/wspr/internal/app.RpcServerOption"` |
| Type RpcServerOption |
| UnionTargetFactory rpcServerOptionTargetFactory |
| Union struct { |
| IsLeaf RpcServerOptionIsLeaf |
| ServesMountTable RpcServerOptionServesMountTable |
| } |
| } |
| ) |
| |
| func (x RpcServerOptionIsLeaf) Index() int { return 0 } |
| func (x RpcServerOptionIsLeaf) Interface() interface{} { return x.Value } |
| func (x RpcServerOptionIsLeaf) Name() string { return "IsLeaf" } |
| func (x RpcServerOptionIsLeaf) __VDLReflect(__RpcServerOptionReflect) {} |
| |
| func (m RpcServerOptionIsLeaf) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("IsLeaf") |
| if err != nil { |
| return err |
| } |
| if err := fieldTarget3.FromBool(bool(m.Value), tt.NonOptional().Field(0).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil { |
| return err |
| } |
| if err := t.FinishFields(fieldsTarget1); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func (m RpcServerOptionIsLeaf) MakeVDLTarget() vdl.Target { |
| return nil |
| } |
| |
| func (x RpcServerOptionServesMountTable) Index() int { return 1 } |
| func (x RpcServerOptionServesMountTable) Interface() interface{} { return x.Value } |
| func (x RpcServerOptionServesMountTable) Name() string { return "ServesMountTable" } |
| func (x RpcServerOptionServesMountTable) __VDLReflect(__RpcServerOptionReflect) {} |
| |
| func (m RpcServerOptionServesMountTable) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("ServesMountTable") |
| if err != nil { |
| return err |
| } |
| if err := fieldTarget3.FromBool(bool(m.Value), tt.NonOptional().Field(1).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil { |
| return err |
| } |
| if err := t.FinishFields(fieldsTarget1); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func (m RpcServerOptionServesMountTable) MakeVDLTarget() vdl.Target { |
| return nil |
| } |
| |
| type RpcServerOptionTarget struct { |
| Value *RpcServerOption |
| fieldName string |
| |
| vdl.TargetBase |
| vdl.FieldsTargetBase |
| } |
| |
| func (t *RpcServerOptionTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) { |
| if ttWant := vdl.TypeOf((*RpcServerOption)(nil)); !vdl.Compatible(tt, ttWant) { |
| return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant) |
| } |
| |
| return t, nil |
| } |
| func (t *RpcServerOptionTarget) StartField(name string) (key, field vdl.Target, _ error) { |
| t.fieldName = name |
| switch name { |
| case "IsLeaf": |
| val := false |
| return nil, &vdl.BoolTarget{Value: &val}, nil |
| case "ServesMountTable": |
| val := false |
| return nil, &vdl.BoolTarget{Value: &val}, nil |
| default: |
| return nil, nil, fmt.Errorf("field %s not in union v.io/x/ref/services/wspr/internal/app.RpcServerOption", name) |
| } |
| } |
| func (t *RpcServerOptionTarget) FinishField(_, fieldTarget vdl.Target) error { |
| switch t.fieldName { |
| case "IsLeaf": |
| *t.Value = RpcServerOptionIsLeaf{*(fieldTarget.(*vdl.BoolTarget)).Value} |
| case "ServesMountTable": |
| *t.Value = RpcServerOptionServesMountTable{*(fieldTarget.(*vdl.BoolTarget)).Value} |
| } |
| return nil |
| } |
| func (t *RpcServerOptionTarget) FinishFields(_ vdl.FieldsTarget) error { |
| |
| return nil |
| } |
| |
| type rpcServerOptionTargetFactory struct{} |
| |
| func (t rpcServerOptionTargetFactory) VDLMakeUnionTarget(union interface{}) (vdl.Target, error) { |
| if typedUnion, ok := union.(*RpcServerOption); ok { |
| return &RpcServerOptionTarget{Value: typedUnion}, nil |
| } |
| return nil, fmt.Errorf("got %T, want *RpcServerOption", union) |
| } |
| |
| type RpcResponse struct { |
| OutArgs []*vom.RawBytes |
| TraceResponse vtrace.Response |
| } |
| |
| func (RpcResponse) __VDLReflect(struct { |
| Name string `vdl:"v.io/x/ref/services/wspr/internal/app.RpcResponse"` |
| }) { |
| } |
| |
| func (m *RpcResponse) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| var var4 bool |
| if len(m.OutArgs) == 0 { |
| var4 = true |
| } |
| if var4 { |
| if err := fieldsTarget1.ZeroField("OutArgs"); err != nil && err != vdl.ErrFieldNoExist { |
| return err |
| } |
| } else { |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("OutArgs") |
| if err != vdl.ErrFieldNoExist { |
| if err != nil { |
| return err |
| } |
| |
| listTarget5, err := fieldTarget3.StartList(tt.NonOptional().Field(0).Type, len(m.OutArgs)) |
| if err != nil { |
| return err |
| } |
| for i, elem7 := range m.OutArgs { |
| elemTarget6, err := listTarget5.StartElem(i) |
| if err != nil { |
| return err |
| } |
| |
| if err := elem7.FillVDLTarget(elemTarget6, tt.NonOptional().Field(0).Type.Elem()); err != nil { |
| return err |
| } |
| if err := listTarget5.FinishElem(elemTarget6); err != nil { |
| return err |
| } |
| } |
| if err := fieldTarget3.FinishList(listTarget5); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil { |
| return err |
| } |
| } |
| } |
| var10 := true |
| var11 := (m.TraceResponse.Flags == vtrace.TraceFlags(0)) |
| var10 = var10 && var11 |
| var12 := true |
| var13 := (m.TraceResponse.Trace.Id == uniqueid.Id{}) |
| var12 = var12 && var13 |
| var var14 bool |
| if len(m.TraceResponse.Trace.Spans) == 0 { |
| var14 = true |
| } |
| var12 = var12 && var14 |
| var10 = var10 && var12 |
| if var10 { |
| if err := fieldsTarget1.ZeroField("TraceResponse"); err != nil && err != vdl.ErrFieldNoExist { |
| return err |
| } |
| } else { |
| keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("TraceResponse") |
| if err != vdl.ErrFieldNoExist { |
| if err != nil { |
| return err |
| } |
| |
| if err := m.TraceResponse.FillVDLTarget(fieldTarget9, tt.NonOptional().Field(1).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil { |
| return err |
| } |
| } |
| } |
| if err := t.FinishFields(fieldsTarget1); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (m *RpcResponse) MakeVDLTarget() vdl.Target { |
| return &RpcResponseTarget{Value: m} |
| } |
| |
| type RpcResponseTarget struct { |
| Value *RpcResponse |
| outArgsTarget __VDLTarget3_list |
| traceResponseTarget vtrace.ResponseTarget |
| vdl.TargetBase |
| vdl.FieldsTargetBase |
| } |
| |
| func (t *RpcResponseTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) { |
| |
| if ttWant := vdl.TypeOf((*RpcResponse)(nil)).Elem(); !vdl.Compatible(tt, ttWant) { |
| return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant) |
| } |
| return t, nil |
| } |
| func (t *RpcResponseTarget) StartField(name string) (key, field vdl.Target, _ error) { |
| switch name { |
| case "OutArgs": |
| t.outArgsTarget.Value = &t.Value.OutArgs |
| target, err := &t.outArgsTarget, error(nil) |
| return nil, target, err |
| case "TraceResponse": |
| t.traceResponseTarget.Value = &t.Value.TraceResponse |
| target, err := &t.traceResponseTarget, error(nil) |
| return nil, target, err |
| default: |
| return nil, nil, fmt.Errorf("field %s not in struct v.io/x/ref/services/wspr/internal/app.RpcResponse", name) |
| } |
| } |
| func (t *RpcResponseTarget) FinishField(_, _ vdl.Target) error { |
| return nil |
| } |
| func (t *RpcResponseTarget) ZeroField(name string) error { |
| switch name { |
| case "OutArgs": |
| t.Value.OutArgs = []*vom.RawBytes(nil) |
| return nil |
| case "TraceResponse": |
| t.Value.TraceResponse = vtrace.Response{} |
| return nil |
| default: |
| return fmt.Errorf("field %s not in struct v.io/x/ref/services/wspr/internal/app.RpcResponse", name) |
| } |
| } |
| func (t *RpcResponseTarget) FinishFields(_ vdl.FieldsTarget) error { |
| |
| return nil |
| } |
| |
| // []*vom.RawBytes |
| type __VDLTarget3_list struct { |
| Value *[]*vom.RawBytes |
| |
| vdl.TargetBase |
| vdl.ListTargetBase |
| } |
| |
| func (t *__VDLTarget3_list) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) { |
| |
| if ttWant := vdl.TypeOf((*[]*vom.RawBytes)(nil)); !vdl.Compatible(tt, ttWant) { |
| return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant) |
| } |
| if cap(*t.Value) < len { |
| *t.Value = make([]*vom.RawBytes, len) |
| } else { |
| *t.Value = (*t.Value)[:len] |
| } |
| return t, nil |
| } |
| func (t *__VDLTarget3_list) StartElem(index int) (elem vdl.Target, _ error) { |
| target, err := vdl.ReflectTarget(reflect.ValueOf(&(*t.Value)[index])) |
| return target, err |
| } |
| func (t *__VDLTarget3_list) FinishElem(elem vdl.Target) error { |
| return nil |
| } |
| func (t *__VDLTarget3_list) FinishList(elem vdl.ListTarget) error { |
| |
| return nil |
| } |
| |
| type GranterRequest struct { |
| GranterHandle GranterHandle |
| Call server.SecurityCall |
| } |
| |
| func (GranterRequest) __VDLReflect(struct { |
| Name string `vdl:"v.io/x/ref/services/wspr/internal/app.GranterRequest"` |
| }) { |
| } |
| |
| func (m *GranterRequest) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| var4 := (m.GranterHandle == GranterHandle(0)) |
| if var4 { |
| if err := fieldsTarget1.ZeroField("GranterHandle"); err != nil && err != vdl.ErrFieldNoExist { |
| return err |
| } |
| } else { |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("GranterHandle") |
| if err != vdl.ErrFieldNoExist { |
| if err != nil { |
| return err |
| } |
| |
| if err := m.GranterHandle.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil { |
| return err |
| } |
| } |
| } |
| var7 := true |
| var8 := (m.Call.Method == "") |
| var7 = var7 && var8 |
| var9 := (m.Call.Suffix == "") |
| var7 = var7 && var9 |
| var var10 bool |
| if len(m.Call.MethodTags) == 0 { |
| var10 = true |
| } |
| var7 = var7 && var10 |
| var11 := (m.Call.LocalBlessings == principal.BlessingsId(0)) |
| var7 = var7 && var11 |
| var var12 bool |
| if len(m.Call.LocalBlessingStrings) == 0 { |
| var12 = true |
| } |
| var7 = var7 && var12 |
| var13 := (m.Call.RemoteBlessings == principal.BlessingsId(0)) |
| var7 = var7 && var13 |
| var var14 bool |
| if len(m.Call.RemoteBlessingStrings) == 0 { |
| var14 = true |
| } |
| var7 = var7 && var14 |
| var15 := (m.Call.LocalEndpoint == "") |
| var7 = var7 && var15 |
| var16 := (m.Call.RemoteEndpoint == "") |
| var7 = var7 && var16 |
| if var7 { |
| if err := fieldsTarget1.ZeroField("Call"); err != nil && err != vdl.ErrFieldNoExist { |
| return err |
| } |
| } else { |
| keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Call") |
| if err != vdl.ErrFieldNoExist { |
| if err != nil { |
| return err |
| } |
| |
| if err := m.Call.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil { |
| return err |
| } |
| } |
| } |
| if err := t.FinishFields(fieldsTarget1); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (m *GranterRequest) MakeVDLTarget() vdl.Target { |
| return &GranterRequestTarget{Value: m} |
| } |
| |
| type GranterRequestTarget struct { |
| Value *GranterRequest |
| granterHandleTarget GranterHandleTarget |
| callTarget server.SecurityCallTarget |
| vdl.TargetBase |
| vdl.FieldsTargetBase |
| } |
| |
| func (t *GranterRequestTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) { |
| |
| if ttWant := vdl.TypeOf((*GranterRequest)(nil)).Elem(); !vdl.Compatible(tt, ttWant) { |
| return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant) |
| } |
| return t, nil |
| } |
| func (t *GranterRequestTarget) StartField(name string) (key, field vdl.Target, _ error) { |
| switch name { |
| case "GranterHandle": |
| t.granterHandleTarget.Value = &t.Value.GranterHandle |
| target, err := &t.granterHandleTarget, error(nil) |
| return nil, target, err |
| case "Call": |
| t.callTarget.Value = &t.Value.Call |
| target, err := &t.callTarget, error(nil) |
| return nil, target, err |
| default: |
| return nil, nil, fmt.Errorf("field %s not in struct v.io/x/ref/services/wspr/internal/app.GranterRequest", name) |
| } |
| } |
| func (t *GranterRequestTarget) FinishField(_, _ vdl.Target) error { |
| return nil |
| } |
| func (t *GranterRequestTarget) ZeroField(name string) error { |
| switch name { |
| case "GranterHandle": |
| t.Value.GranterHandle = GranterHandle(0) |
| return nil |
| case "Call": |
| t.Value.Call = server.SecurityCall{} |
| return nil |
| default: |
| return fmt.Errorf("field %s not in struct v.io/x/ref/services/wspr/internal/app.GranterRequest", name) |
| } |
| } |
| func (t *GranterRequestTarget) FinishFields(_ vdl.FieldsTarget) error { |
| |
| return nil |
| } |
| |
| type GranterResponse struct { |
| Blessings security.Blessings |
| Err error |
| } |
| |
| func (GranterResponse) __VDLReflect(struct { |
| Name string `vdl:"v.io/x/ref/services/wspr/internal/app.GranterResponse"` |
| }) { |
| } |
| |
| func (m *GranterResponse) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| var wireValue2 security.WireBlessings |
| if err := security.WireBlessingsFromNative(&wireValue2, m.Blessings); err != nil { |
| return err |
| } |
| |
| var5 := true |
| var var6 bool |
| if len(wireValue2.CertificateChains) == 0 { |
| var6 = true |
| } |
| var5 = var5 && var6 |
| if var5 { |
| if err := fieldsTarget1.ZeroField("Blessings"); err != nil && err != vdl.ErrFieldNoExist { |
| return err |
| } |
| } else { |
| keyTarget3, fieldTarget4, err := fieldsTarget1.StartField("Blessings") |
| if err != vdl.ErrFieldNoExist { |
| if err != nil { |
| return err |
| } |
| |
| if err := wireValue2.FillVDLTarget(fieldTarget4, tt.NonOptional().Field(0).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget3, fieldTarget4); err != nil { |
| return err |
| } |
| } |
| } |
| var9 := (m.Err == (error)(nil)) |
| if var9 { |
| if err := fieldsTarget1.ZeroField("Err"); err != nil && err != vdl.ErrFieldNoExist { |
| return err |
| } |
| } else { |
| keyTarget7, fieldTarget8, err := fieldsTarget1.StartField("Err") |
| if err != vdl.ErrFieldNoExist { |
| if err != nil { |
| return err |
| } |
| |
| var wireError10 vdl.WireError |
| if err := verror.WireFromNative(&wireError10, m.Err); err != nil { |
| return err |
| } |
| if err := wireError10.FillVDLTarget(fieldTarget8, vdl.ErrorType); err != nil { |
| return err |
| } |
| |
| if err := fieldsTarget1.FinishField(keyTarget7, fieldTarget8); err != nil { |
| return err |
| } |
| } |
| } |
| if err := t.FinishFields(fieldsTarget1); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (m *GranterResponse) MakeVDLTarget() vdl.Target { |
| return &GranterResponseTarget{Value: m} |
| } |
| |
| type GranterResponseTarget struct { |
| Value *GranterResponse |
| blessingsTarget security.WireBlessingsTarget |
| errTarget verror.ErrorTarget |
| vdl.TargetBase |
| vdl.FieldsTargetBase |
| } |
| |
| func (t *GranterResponseTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) { |
| |
| if ttWant := vdl.TypeOf((*GranterResponse)(nil)).Elem(); !vdl.Compatible(tt, ttWant) { |
| return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant) |
| } |
| return t, nil |
| } |
| func (t *GranterResponseTarget) StartField(name string) (key, field vdl.Target, _ error) { |
| switch name { |
| case "Blessings": |
| t.blessingsTarget.Value = &t.Value.Blessings |
| target, err := &t.blessingsTarget, error(nil) |
| return nil, target, err |
| case "Err": |
| t.errTarget.Value = &t.Value.Err |
| target, err := &t.errTarget, error(nil) |
| return nil, target, err |
| default: |
| return nil, nil, fmt.Errorf("field %s not in struct v.io/x/ref/services/wspr/internal/app.GranterResponse", name) |
| } |
| } |
| func (t *GranterResponseTarget) FinishField(_, _ vdl.Target) error { |
| return nil |
| } |
| func (t *GranterResponseTarget) ZeroField(name string) error { |
| switch name { |
| case "Blessings": |
| t.Value.Blessings = func() security.Blessings { |
| var native security.Blessings |
| if err := vdl.Convert(&native, security.WireBlessings{}); err != nil { |
| panic(err) |
| } |
| return native |
| }() |
| return nil |
| case "Err": |
| t.Value.Err = (error)(nil) |
| return nil |
| default: |
| return fmt.Errorf("field %s not in struct v.io/x/ref/services/wspr/internal/app.GranterResponse", name) |
| } |
| } |
| func (t *GranterResponseTarget) FinishFields(_ vdl.FieldsTarget) error { |
| |
| return nil |
| } |
| |
| ////////////////////////////////////////////////// |
| // Interface definitions |
| |
| // ControllerClientMethods is the client interface |
| // containing Controller methods. |
| type ControllerClientMethods interface { |
| // NewServer instructs WSPR to create a server and start listening for calls on |
| // behalf of a JavaScript server. |
| NewServer(_ *context.T, name string, serverId uint32, serverOpts []RpcServerOption, _ ...rpc.CallOpt) error |
| // Stop instructs WSPR to stop listening for calls for the |
| // given javascript server. |
| Stop(_ *context.T, serverId uint32, _ ...rpc.CallOpt) error |
| // AddName adds a published name to an existing server. |
| AddName(_ *context.T, serverId uint32, name string, _ ...rpc.CallOpt) error |
| // RemoveName removes a published name from an existing server. |
| RemoveName(_ *context.T, serverId uint32, name string, _ ...rpc.CallOpt) error |
| // Bless binds extensions of blessings held by this principal to |
| // another principal (represented by its public key). |
| Bless(_ *context.T, publicKey []byte, blessings security.Blessings, extension string, caveat []security.Caveat, _ ...rpc.CallOpt) (principal.BlessingsId, error) |
| // BlessSelf creates a blessing with the provided name for this principal. |
| BlessSelf(_ *context.T, name string, caveats []security.Caveat, _ ...rpc.CallOpt) (principal.BlessingsId, error) |
| // AddToRoots adds the provided blessing as a root. |
| AddToRoots(_ *context.T, blessings security.Blessings, _ ...rpc.CallOpt) error |
| // BlessingStoreSet puts the specified blessing in the blessing store under the provided pattern. |
| BlessingStoreSet(_ *context.T, blessingsblessings security.Blessings, pattern security.BlessingPattern, _ ...rpc.CallOpt) (principal.BlessingsId, error) |
| // BlessingStoreForPeer retrieves the blessings marked for the given peers. |
| BlessingStoreForPeer(_ *context.T, peerBlessings []string, _ ...rpc.CallOpt) (principal.BlessingsId, error) |
| // BlessingStoreSetDefault sets the default blessings. |
| BlessingStoreSetDefault(_ *context.T, blessingsblessings security.Blessings, _ ...rpc.CallOpt) error |
| // BlessingStoreDefault fetches the default blessings for the principal of the controller. |
| BlessingStoreDefault(*context.T, ...rpc.CallOpt) (principal.BlessingsId, error) |
| // BlessingStorePublicKey fetches the public key of the principal for which this store hosts blessings. |
| BlessingStorePublicKey(*context.T, ...rpc.CallOpt) ([]byte, error) |
| // BlessingStorePeerBlessings returns all the blessings that the BlessingStore holds. |
| BlessingStorePeerBlessings(*context.T, ...rpc.CallOpt) (map[security.BlessingPattern]principal.BlessingsId, error) |
| // BlessingStoreDebugString retrieves a debug string describing the state of the blessing store |
| BlessingStoreDebugString(*context.T, ...rpc.CallOpt) (string, error) |
| // RemoteBlessings fetches the remote blessings for a given name and method. |
| RemoteBlessings(_ *context.T, name string, method string, _ ...rpc.CallOpt) ([]string, error) |
| // Signature fetches the signature for a given name. |
| Signature(_ *context.T, name string, _ ...rpc.CallOpt) ([]signature.Interface, error) |
| } |
| |
| // ControllerClientStub adds universal methods to ControllerClientMethods. |
| type ControllerClientStub interface { |
| ControllerClientMethods |
| rpc.UniversalServiceMethods |
| } |
| |
| // ControllerClient returns a client stub for Controller. |
| func ControllerClient(name string) ControllerClientStub { |
| return implControllerClientStub{name} |
| } |
| |
| type implControllerClientStub struct { |
| name string |
| } |
| |
| func (c implControllerClientStub) NewServer(ctx *context.T, i0 string, i1 uint32, i2 []RpcServerOption, opts ...rpc.CallOpt) (err error) { |
| err = v23.GetClient(ctx).Call(ctx, c.name, "NewServer", []interface{}{i0, i1, i2}, nil, opts...) |
| return |
| } |
| |
| func (c implControllerClientStub) Stop(ctx *context.T, i0 uint32, opts ...rpc.CallOpt) (err error) { |
| err = v23.GetClient(ctx).Call(ctx, c.name, "Stop", []interface{}{i0}, nil, opts...) |
| return |
| } |
| |
| func (c implControllerClientStub) AddName(ctx *context.T, i0 uint32, i1 string, opts ...rpc.CallOpt) (err error) { |
| err = v23.GetClient(ctx).Call(ctx, c.name, "AddName", []interface{}{i0, i1}, nil, opts...) |
| return |
| } |
| |
| func (c implControllerClientStub) RemoveName(ctx *context.T, i0 uint32, i1 string, opts ...rpc.CallOpt) (err error) { |
| err = v23.GetClient(ctx).Call(ctx, c.name, "RemoveName", []interface{}{i0, i1}, nil, opts...) |
| return |
| } |
| |
| func (c implControllerClientStub) Bless(ctx *context.T, i0 []byte, i1 security.Blessings, i2 string, i3 []security.Caveat, opts ...rpc.CallOpt) (o0 principal.BlessingsId, err error) { |
| err = v23.GetClient(ctx).Call(ctx, c.name, "Bless", []interface{}{i0, i1, i2, i3}, []interface{}{&o0}, opts...) |
| return |
| } |
| |
| func (c implControllerClientStub) BlessSelf(ctx *context.T, i0 string, i1 []security.Caveat, opts ...rpc.CallOpt) (o0 principal.BlessingsId, err error) { |
| err = v23.GetClient(ctx).Call(ctx, c.name, "BlessSelf", []interface{}{i0, i1}, []interface{}{&o0}, opts...) |
| return |
| } |
| |
| func (c implControllerClientStub) AddToRoots(ctx *context.T, i0 security.Blessings, opts ...rpc.CallOpt) (err error) { |
| err = v23.GetClient(ctx).Call(ctx, c.name, "AddToRoots", []interface{}{i0}, nil, opts...) |
| return |
| } |
| |
| func (c implControllerClientStub) BlessingStoreSet(ctx *context.T, i0 security.Blessings, i1 security.BlessingPattern, opts ...rpc.CallOpt) (o0 principal.BlessingsId, err error) { |
| err = v23.GetClient(ctx).Call(ctx, c.name, "BlessingStoreSet", []interface{}{i0, i1}, []interface{}{&o0}, opts...) |
| return |
| } |
| |
| func (c implControllerClientStub) BlessingStoreForPeer(ctx *context.T, i0 []string, opts ...rpc.CallOpt) (o0 principal.BlessingsId, err error) { |
| err = v23.GetClient(ctx).Call(ctx, c.name, "BlessingStoreForPeer", []interface{}{i0}, []interface{}{&o0}, opts...) |
| return |
| } |
| |
| func (c implControllerClientStub) BlessingStoreSetDefault(ctx *context.T, i0 security.Blessings, opts ...rpc.CallOpt) (err error) { |
| err = v23.GetClient(ctx).Call(ctx, c.name, "BlessingStoreSetDefault", []interface{}{i0}, nil, opts...) |
| return |
| } |
| |
| func (c implControllerClientStub) BlessingStoreDefault(ctx *context.T, opts ...rpc.CallOpt) (o0 principal.BlessingsId, err error) { |
| err = v23.GetClient(ctx).Call(ctx, c.name, "BlessingStoreDefault", nil, []interface{}{&o0}, opts...) |
| return |
| } |
| |
| func (c implControllerClientStub) BlessingStorePublicKey(ctx *context.T, opts ...rpc.CallOpt) (o0 []byte, err error) { |
| err = v23.GetClient(ctx).Call(ctx, c.name, "BlessingStorePublicKey", nil, []interface{}{&o0}, opts...) |
| return |
| } |
| |
| func (c implControllerClientStub) BlessingStorePeerBlessings(ctx *context.T, opts ...rpc.CallOpt) (o0 map[security.BlessingPattern]principal.BlessingsId, err error) { |
| err = v23.GetClient(ctx).Call(ctx, c.name, "BlessingStorePeerBlessings", nil, []interface{}{&o0}, opts...) |
| return |
| } |
| |
| func (c implControllerClientStub) BlessingStoreDebugString(ctx *context.T, opts ...rpc.CallOpt) (o0 string, err error) { |
| err = v23.GetClient(ctx).Call(ctx, c.name, "BlessingStoreDebugString", nil, []interface{}{&o0}, opts...) |
| return |
| } |
| |
| func (c implControllerClientStub) RemoteBlessings(ctx *context.T, i0 string, i1 string, opts ...rpc.CallOpt) (o0 []string, err error) { |
| err = v23.GetClient(ctx).Call(ctx, c.name, "RemoteBlessings", []interface{}{i0, i1}, []interface{}{&o0}, opts...) |
| return |
| } |
| |
| func (c implControllerClientStub) Signature(ctx *context.T, i0 string, opts ...rpc.CallOpt) (o0 []signature.Interface, err error) { |
| err = v23.GetClient(ctx).Call(ctx, c.name, "Signature", []interface{}{i0}, []interface{}{&o0}, opts...) |
| return |
| } |
| |
| // ControllerServerMethods is the interface a server writer |
| // implements for Controller. |
| type ControllerServerMethods interface { |
| // NewServer instructs WSPR to create a server and start listening for calls on |
| // behalf of a JavaScript server. |
| NewServer(_ *context.T, _ rpc.ServerCall, name string, serverId uint32, serverOpts []RpcServerOption) error |
| // Stop instructs WSPR to stop listening for calls for the |
| // given javascript server. |
| Stop(_ *context.T, _ rpc.ServerCall, serverId uint32) error |
| // AddName adds a published name to an existing server. |
| AddName(_ *context.T, _ rpc.ServerCall, serverId uint32, name string) error |
| // RemoveName removes a published name from an existing server. |
| RemoveName(_ *context.T, _ rpc.ServerCall, serverId uint32, name string) error |
| // Bless binds extensions of blessings held by this principal to |
| // another principal (represented by its public key). |
| Bless(_ *context.T, _ rpc.ServerCall, publicKey []byte, blessings security.Blessings, extension string, caveat []security.Caveat) (principal.BlessingsId, error) |
| // BlessSelf creates a blessing with the provided name for this principal. |
| BlessSelf(_ *context.T, _ rpc.ServerCall, name string, caveats []security.Caveat) (principal.BlessingsId, error) |
| // AddToRoots adds the provided blessing as a root. |
| AddToRoots(_ *context.T, _ rpc.ServerCall, blessings security.Blessings) error |
| // BlessingStoreSet puts the specified blessing in the blessing store under the provided pattern. |
| BlessingStoreSet(_ *context.T, _ rpc.ServerCall, blessingsblessings security.Blessings, pattern security.BlessingPattern) (principal.BlessingsId, error) |
| // BlessingStoreForPeer retrieves the blessings marked for the given peers. |
| BlessingStoreForPeer(_ *context.T, _ rpc.ServerCall, peerBlessings []string) (principal.BlessingsId, error) |
| // BlessingStoreSetDefault sets the default blessings. |
| BlessingStoreSetDefault(_ *context.T, _ rpc.ServerCall, blessingsblessings security.Blessings) error |
| // BlessingStoreDefault fetches the default blessings for the principal of the controller. |
| BlessingStoreDefault(*context.T, rpc.ServerCall) (principal.BlessingsId, error) |
| // BlessingStorePublicKey fetches the public key of the principal for which this store hosts blessings. |
| BlessingStorePublicKey(*context.T, rpc.ServerCall) ([]byte, error) |
| // BlessingStorePeerBlessings returns all the blessings that the BlessingStore holds. |
| BlessingStorePeerBlessings(*context.T, rpc.ServerCall) (map[security.BlessingPattern]principal.BlessingsId, error) |
| // BlessingStoreDebugString retrieves a debug string describing the state of the blessing store |
| BlessingStoreDebugString(*context.T, rpc.ServerCall) (string, error) |
| // RemoteBlessings fetches the remote blessings for a given name and method. |
| RemoteBlessings(_ *context.T, _ rpc.ServerCall, name string, method string) ([]string, error) |
| // Signature fetches the signature for a given name. |
| Signature(_ *context.T, _ rpc.ServerCall, name string) ([]signature.Interface, error) |
| } |
| |
| // ControllerServerStubMethods is the server interface containing |
| // Controller methods, as expected by rpc.Server. |
| // There is no difference between this interface and ControllerServerMethods |
| // since there are no streaming methods. |
| type ControllerServerStubMethods ControllerServerMethods |
| |
| // ControllerServerStub adds universal methods to ControllerServerStubMethods. |
| type ControllerServerStub interface { |
| ControllerServerStubMethods |
| // Describe the Controller interfaces. |
| Describe__() []rpc.InterfaceDesc |
| } |
| |
| // ControllerServer returns a server stub for Controller. |
| // It converts an implementation of ControllerServerMethods into |
| // an object that may be used by rpc.Server. |
| func ControllerServer(impl ControllerServerMethods) ControllerServerStub { |
| stub := implControllerServerStub{ |
| 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 implControllerServerStub struct { |
| impl ControllerServerMethods |
| gs *rpc.GlobState |
| } |
| |
| func (s implControllerServerStub) NewServer(ctx *context.T, call rpc.ServerCall, i0 string, i1 uint32, i2 []RpcServerOption) error { |
| return s.impl.NewServer(ctx, call, i0, i1, i2) |
| } |
| |
| func (s implControllerServerStub) Stop(ctx *context.T, call rpc.ServerCall, i0 uint32) error { |
| return s.impl.Stop(ctx, call, i0) |
| } |
| |
| func (s implControllerServerStub) AddName(ctx *context.T, call rpc.ServerCall, i0 uint32, i1 string) error { |
| return s.impl.AddName(ctx, call, i0, i1) |
| } |
| |
| func (s implControllerServerStub) RemoveName(ctx *context.T, call rpc.ServerCall, i0 uint32, i1 string) error { |
| return s.impl.RemoveName(ctx, call, i0, i1) |
| } |
| |
| func (s implControllerServerStub) Bless(ctx *context.T, call rpc.ServerCall, i0 []byte, i1 security.Blessings, i2 string, i3 []security.Caveat) (principal.BlessingsId, error) { |
| return s.impl.Bless(ctx, call, i0, i1, i2, i3) |
| } |
| |
| func (s implControllerServerStub) BlessSelf(ctx *context.T, call rpc.ServerCall, i0 string, i1 []security.Caveat) (principal.BlessingsId, error) { |
| return s.impl.BlessSelf(ctx, call, i0, i1) |
| } |
| |
| func (s implControllerServerStub) AddToRoots(ctx *context.T, call rpc.ServerCall, i0 security.Blessings) error { |
| return s.impl.AddToRoots(ctx, call, i0) |
| } |
| |
| func (s implControllerServerStub) BlessingStoreSet(ctx *context.T, call rpc.ServerCall, i0 security.Blessings, i1 security.BlessingPattern) (principal.BlessingsId, error) { |
| return s.impl.BlessingStoreSet(ctx, call, i0, i1) |
| } |
| |
| func (s implControllerServerStub) BlessingStoreForPeer(ctx *context.T, call rpc.ServerCall, i0 []string) (principal.BlessingsId, error) { |
| return s.impl.BlessingStoreForPeer(ctx, call, i0) |
| } |
| |
| func (s implControllerServerStub) BlessingStoreSetDefault(ctx *context.T, call rpc.ServerCall, i0 security.Blessings) error { |
| return s.impl.BlessingStoreSetDefault(ctx, call, i0) |
| } |
| |
| func (s implControllerServerStub) BlessingStoreDefault(ctx *context.T, call rpc.ServerCall) (principal.BlessingsId, error) { |
| return s.impl.BlessingStoreDefault(ctx, call) |
| } |
| |
| func (s implControllerServerStub) BlessingStorePublicKey(ctx *context.T, call rpc.ServerCall) ([]byte, error) { |
| return s.impl.BlessingStorePublicKey(ctx, call) |
| } |
| |
| func (s implControllerServerStub) BlessingStorePeerBlessings(ctx *context.T, call rpc.ServerCall) (map[security.BlessingPattern]principal.BlessingsId, error) { |
| return s.impl.BlessingStorePeerBlessings(ctx, call) |
| } |
| |
| func (s implControllerServerStub) BlessingStoreDebugString(ctx *context.T, call rpc.ServerCall) (string, error) { |
| return s.impl.BlessingStoreDebugString(ctx, call) |
| } |
| |
| func (s implControllerServerStub) RemoteBlessings(ctx *context.T, call rpc.ServerCall, i0 string, i1 string) ([]string, error) { |
| return s.impl.RemoteBlessings(ctx, call, i0, i1) |
| } |
| |
| func (s implControllerServerStub) Signature(ctx *context.T, call rpc.ServerCall, i0 string) ([]signature.Interface, error) { |
| return s.impl.Signature(ctx, call, i0) |
| } |
| |
| func (s implControllerServerStub) Globber() *rpc.GlobState { |
| return s.gs |
| } |
| |
| func (s implControllerServerStub) Describe__() []rpc.InterfaceDesc { |
| return []rpc.InterfaceDesc{ControllerDesc} |
| } |
| |
| // ControllerDesc describes the Controller interface. |
| var ControllerDesc rpc.InterfaceDesc = descController |
| |
| // descController hides the desc to keep godoc clean. |
| var descController = rpc.InterfaceDesc{ |
| Name: "Controller", |
| PkgPath: "v.io/x/ref/services/wspr/internal/app", |
| Methods: []rpc.MethodDesc{ |
| { |
| Name: "NewServer", |
| Doc: "// NewServer instructs WSPR to create a server and start listening for calls on\n// behalf of a JavaScript server.", |
| InArgs: []rpc.ArgDesc{ |
| {"name", ``}, // string |
| {"serverId", ``}, // uint32 |
| {"serverOpts", ``}, // []RpcServerOption |
| }, |
| }, |
| { |
| Name: "Stop", |
| Doc: "// Stop instructs WSPR to stop listening for calls for the\n// given javascript server.", |
| InArgs: []rpc.ArgDesc{ |
| {"serverId", ``}, // uint32 |
| }, |
| }, |
| { |
| Name: "AddName", |
| Doc: "// AddName adds a published name to an existing server.", |
| InArgs: []rpc.ArgDesc{ |
| {"serverId", ``}, // uint32 |
| {"name", ``}, // string |
| }, |
| }, |
| { |
| Name: "RemoveName", |
| Doc: "// RemoveName removes a published name from an existing server.", |
| InArgs: []rpc.ArgDesc{ |
| {"serverId", ``}, // uint32 |
| {"name", ``}, // string |
| }, |
| }, |
| { |
| Name: "Bless", |
| Doc: "// Bless binds extensions of blessings held by this principal to\n// another principal (represented by its public key).", |
| InArgs: []rpc.ArgDesc{ |
| {"publicKey", ``}, // []byte |
| {"blessings", ``}, // security.Blessings |
| {"extension", ``}, // string |
| {"caveat", ``}, // []security.Caveat |
| }, |
| OutArgs: []rpc.ArgDesc{ |
| {"", ``}, // principal.BlessingsId |
| }, |
| }, |
| { |
| Name: "BlessSelf", |
| Doc: "// BlessSelf creates a blessing with the provided name for this principal.", |
| InArgs: []rpc.ArgDesc{ |
| {"name", ``}, // string |
| {"caveats", ``}, // []security.Caveat |
| }, |
| OutArgs: []rpc.ArgDesc{ |
| {"", ``}, // principal.BlessingsId |
| }, |
| }, |
| { |
| Name: "AddToRoots", |
| Doc: "// AddToRoots adds the provided blessing as a root.", |
| InArgs: []rpc.ArgDesc{ |
| {"blessings", ``}, // security.Blessings |
| }, |
| }, |
| { |
| Name: "BlessingStoreSet", |
| Doc: "// BlessingStoreSet puts the specified blessing in the blessing store under the provided pattern.", |
| InArgs: []rpc.ArgDesc{ |
| {"blessingsblessings", ``}, // security.Blessings |
| {"pattern", ``}, // security.BlessingPattern |
| }, |
| OutArgs: []rpc.ArgDesc{ |
| {"", ``}, // principal.BlessingsId |
| }, |
| }, |
| { |
| Name: "BlessingStoreForPeer", |
| Doc: "// BlessingStoreForPeer retrieves the blessings marked for the given peers.", |
| InArgs: []rpc.ArgDesc{ |
| {"peerBlessings", ``}, // []string |
| }, |
| OutArgs: []rpc.ArgDesc{ |
| {"", ``}, // principal.BlessingsId |
| }, |
| }, |
| { |
| Name: "BlessingStoreSetDefault", |
| Doc: "// BlessingStoreSetDefault sets the default blessings.", |
| InArgs: []rpc.ArgDesc{ |
| {"blessingsblessings", ``}, // security.Blessings |
| }, |
| }, |
| { |
| Name: "BlessingStoreDefault", |
| Doc: "// BlessingStoreDefault fetches the default blessings for the principal of the controller.", |
| OutArgs: []rpc.ArgDesc{ |
| {"", ``}, // principal.BlessingsId |
| }, |
| }, |
| { |
| Name: "BlessingStorePublicKey", |
| Doc: "// BlessingStorePublicKey fetches the public key of the principal for which this store hosts blessings.", |
| OutArgs: []rpc.ArgDesc{ |
| {"", ``}, // []byte |
| }, |
| }, |
| { |
| Name: "BlessingStorePeerBlessings", |
| Doc: "// BlessingStorePeerBlessings returns all the blessings that the BlessingStore holds.", |
| OutArgs: []rpc.ArgDesc{ |
| {"", ``}, // map[security.BlessingPattern]principal.BlessingsId |
| }, |
| }, |
| { |
| Name: "BlessingStoreDebugString", |
| Doc: "// BlessingStoreDebugString retrieves a debug string describing the state of the blessing store", |
| OutArgs: []rpc.ArgDesc{ |
| {"", ``}, // string |
| }, |
| }, |
| { |
| Name: "RemoteBlessings", |
| Doc: "// RemoteBlessings fetches the remote blessings for a given name and method.", |
| InArgs: []rpc.ArgDesc{ |
| {"name", ``}, // string |
| {"method", ``}, // string |
| }, |
| OutArgs: []rpc.ArgDesc{ |
| {"", ``}, // []string |
| }, |
| }, |
| { |
| Name: "Signature", |
| Doc: "// Signature fetches the signature for a given name.", |
| InArgs: []rpc.ArgDesc{ |
| {"name", ``}, // string |
| }, |
| OutArgs: []rpc.ArgDesc{ |
| {"", ``}, // []signature.Interface |
| }, |
| }, |
| }, |
| } |
| |
| 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((*GranterHandle)(nil)) |
| vdl.Register((*RpcCallOption)(nil)) |
| vdl.Register((*RpcRequest)(nil)) |
| vdl.Register((*RpcServerOption)(nil)) |
| vdl.Register((*RpcResponse)(nil)) |
| vdl.Register((*GranterRequest)(nil)) |
| vdl.Register((*GranterResponse)(nil)) |
| |
| return struct{}{} |
| } |
