| // 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: ifc |
| |
| // Package messenger defines interfaces for peer-to-peer messaging where the |
| // originator of the message and its recipient don't necessarily have a direct |
| // network connection. |
| // |
| // Messages are opportunistically relayed from device to device until they |
| // reach their destination. |
| package ifc |
| |
| import ( |
| "io" |
| "time" |
| "v.io/v23" |
| "v.io/v23/context" |
| "v.io/v23/i18n" |
| "v.io/v23/rpc" |
| "v.io/v23/security" |
| "v.io/v23/vdl" |
| vdltime "v.io/v23/vdlroot/time" |
| "v.io/v23/verror" |
| ) |
| |
| var _ = __VDLInit() // Must be first; see __VDLInit comments for details. |
| |
| ////////////////////////////////////////////////// |
| // Type definitions |
| |
| // Message contains the metadata of a message, not the content of the message. |
| // It is EXPERIMENTAL and can change at any time. |
| type Message struct { |
| // The list of nodes that have relayed this message. Each node |
| // must add its own name to the list before sending it to another |
| // node, either via Push() or Pull(). |
| Hops []string |
| // The identity of the sender. Can be used to both authenticate |
| // the message and to authorize sending or relaying it. |
| SenderBlessings security.Blessings |
| // Any required discharges to prove the sender blessings are still |
| // valid. |
| SenderDischarges map[string]security.Discharge |
| // Proof that the sender sent this message. The signature covers |
| // all the fields below. |
| Signature security.Signature |
| // The unique ID of this message. |
| Id string |
| // The intended recipient of the message. |
| // TBD: blessing pattern or email? Or something else? |
| Recipient string |
| // When the message was created. |
| CreationTime time.Time |
| // The lifespan of the message. The message can be deleted by everyone |
| // when CreationTime + Lifespan has been reached. |
| Lifespan time.Duration |
| // The length of the message's content. |
| Length int64 |
| // The sha256 hash of the message's content. |
| Sha256 []byte |
| } |
| |
| func (Message) __VDLReflect(struct { |
| Name string `vdl:"messenger/ifc.Message"` |
| }) { |
| } |
| |
| func (x Message) VDLIsZero() bool { |
| if len(x.Hops) != 0 { |
| return false |
| } |
| if !x.SenderBlessings.IsZero() { |
| return false |
| } |
| if len(x.SenderDischarges) != 0 { |
| return false |
| } |
| if !x.Signature.VDLIsZero() { |
| return false |
| } |
| if x.Id != "" { |
| return false |
| } |
| if x.Recipient != "" { |
| return false |
| } |
| if !x.CreationTime.IsZero() { |
| return false |
| } |
| if x.Lifespan != 0 { |
| return false |
| } |
| if x.Length != 0 { |
| return false |
| } |
| if len(x.Sha256) != 0 { |
| return false |
| } |
| return true |
| } |
| |
| func (x Message) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(__VDLType_struct_1); err != nil { |
| return err |
| } |
| if len(x.Hops) != 0 { |
| if err := enc.NextField(0); err != nil { |
| return err |
| } |
| if err := __VDLWriteAnon_list_1(enc, x.Hops); err != nil { |
| return err |
| } |
| } |
| if !x.SenderBlessings.IsZero() { |
| if err := enc.NextField(1); err != nil { |
| return err |
| } |
| var wire security.WireBlessings |
| if err := security.WireBlessingsFromNative(&wire, x.SenderBlessings); err != nil { |
| return err |
| } |
| if err := wire.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if len(x.SenderDischarges) != 0 { |
| if err := enc.NextField(2); err != nil { |
| return err |
| } |
| if err := __VDLWriteAnon_map_2(enc, x.SenderDischarges); err != nil { |
| return err |
| } |
| } |
| if !x.Signature.VDLIsZero() { |
| if err := enc.NextField(3); err != nil { |
| return err |
| } |
| if err := x.Signature.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if x.Id != "" { |
| if err := enc.NextFieldValueString(4, vdl.StringType, x.Id); err != nil { |
| return err |
| } |
| } |
| if x.Recipient != "" { |
| if err := enc.NextFieldValueString(5, vdl.StringType, x.Recipient); err != nil { |
| return err |
| } |
| } |
| if !x.CreationTime.IsZero() { |
| if err := enc.NextField(6); err != nil { |
| return err |
| } |
| var wire vdltime.Time |
| if err := vdltime.TimeFromNative(&wire, x.CreationTime); err != nil { |
| return err |
| } |
| if err := wire.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if x.Lifespan != 0 { |
| if err := enc.NextField(7); err != nil { |
| return err |
| } |
| var wire vdltime.Duration |
| if err := vdltime.DurationFromNative(&wire, x.Lifespan); err != nil { |
| return err |
| } |
| if err := wire.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if x.Length != 0 { |
| if err := enc.NextFieldValueInt(8, vdl.Int64Type, x.Length); err != nil { |
| return err |
| } |
| } |
| if len(x.Sha256) != 0 { |
| if err := enc.NextFieldValueBytes(9, __VDLType_list_8, x.Sha256); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextField(-1); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func __VDLWriteAnon_list_1(enc vdl.Encoder, x []string) error { |
| if err := enc.StartValue(__VDLType_list_2); 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 __VDLWriteAnon_map_2(enc vdl.Encoder, x map[string]security.Discharge) error { |
| if err := enc.StartValue(__VDLType_map_4); 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 |
| } |
| var wire security.WireDischarge |
| if err := security.WireDischargeFromNative(&wire, elem); err != nil { |
| return err |
| } |
| switch { |
| case wire == nil: |
| // Write the zero value of the union type. |
| if err := vdl.ZeroValue(__VDLType_union_9).VDLWrite(enc); err != nil { |
| return err |
| } |
| default: |
| if err := wire.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *Message) VDLRead(dec vdl.Decoder) error { |
| *x = Message{} |
| 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: |
| if err := __VDLReadAnon_list_1(dec, &x.Hops); err != nil { |
| return err |
| } |
| case 1: |
| var wire security.WireBlessings |
| if err := wire.VDLRead(dec); err != nil { |
| return err |
| } |
| if err := security.WireBlessingsToNative(wire, &x.SenderBlessings); err != nil { |
| return err |
| } |
| case 2: |
| if err := __VDLReadAnon_map_2(dec, &x.SenderDischarges); err != nil { |
| return err |
| } |
| case 3: |
| if err := x.Signature.VDLRead(dec); err != nil { |
| return err |
| } |
| case 4: |
| switch value, err := dec.ReadValueString(); { |
| case err != nil: |
| return err |
| default: |
| x.Id = value |
| } |
| case 5: |
| switch value, err := dec.ReadValueString(); { |
| case err != nil: |
| return err |
| default: |
| x.Recipient = value |
| } |
| case 6: |
| var wire vdltime.Time |
| if err := wire.VDLRead(dec); err != nil { |
| return err |
| } |
| if err := vdltime.TimeToNative(wire, &x.CreationTime); err != nil { |
| return err |
| } |
| case 7: |
| var wire vdltime.Duration |
| if err := wire.VDLRead(dec); err != nil { |
| return err |
| } |
| if err := vdltime.DurationToNative(wire, &x.Lifespan); err != nil { |
| return err |
| } |
| case 8: |
| switch value, err := dec.ReadValueInt(64); { |
| case err != nil: |
| return err |
| default: |
| x.Length = value |
| } |
| case 9: |
| if err := dec.ReadValueBytes(-1, &x.Sha256); err != nil { |
| return err |
| } |
| } |
| } |
| } |
| |
| func __VDLReadAnon_list_1(dec vdl.Decoder, x *[]string) error { |
| if err := dec.StartValue(__VDLType_list_2); 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) |
| } |
| } |
| } |
| |
| func __VDLReadAnon_map_2(dec vdl.Decoder, x *map[string]security.Discharge) error { |
| if err := dec.StartValue(__VDLType_map_4); err != nil { |
| return err |
| } |
| var tmpMap map[string]security.Discharge |
| if len := dec.LenHint(); len > 0 { |
| tmpMap = make(map[string]security.Discharge, len) |
| } |
| for { |
| switch done, key, err := dec.NextEntryValueString(); { |
| case err != nil: |
| return err |
| case done: |
| *x = tmpMap |
| return dec.FinishValue() |
| default: |
| var elem security.Discharge |
| var wire security.WireDischarge |
| if err := security.VDLReadWireDischarge(dec, &wire); err != nil { |
| return err |
| } |
| if err := security.WireDischargeToNative(wire, &elem); err != nil { |
| return err |
| } |
| if tmpMap == nil { |
| tmpMap = make(map[string]security.Discharge) |
| } |
| tmpMap[key] = elem |
| } |
| } |
| } |
| |
| ////////////////////////////////////////////////// |
| // Error definitions |
| |
| var ( |
| ErrAlreadySeen = verror.Register("messenger/ifc.AlreadySeen", verror.NoRetry, "{1:}{2:} message id already seen: {3}") |
| ErrBusy = verror.Register("messenger/ifc.Busy", verror.RetryBackoff, "{1:}{2:} message is already opened") |
| ErrContentMismatch = verror.Register("messenger/ifc.ContentMismatch", verror.NoRetry, "{1:}{2:} the sha256 hash doesn't match the message content") |
| ErrExpired = verror.Register("messenger/ifc.Expired", verror.NoRetry, "{1:}{2:} message lifespan expired: {3} + {4} < {5}") |
| ErrIncorrectOffset = verror.Register("messenger/ifc.IncorrectOffset", verror.NoRetry, "{1:}{2:} the specified file offset is incorrect ({3} != {4})") |
| ErrInvalidSignature = verror.Register("messenger/ifc.InvalidSignature", verror.NoRetry, "{1:}{2:} message signature is invalid") |
| ErrMessageIdCollision = verror.Register("messenger/ifc.MessageIdCollision", verror.NoRetry, "{1:}{2:} message id already seen with different content: {3}") |
| ErrNoRoute = verror.Register("messenger/ifc.NoRoute", verror.NoRetry, "{1:}{2:} no route for recipient: {3}") |
| ErrRateLimitExceeded = verror.Register("messenger/ifc.RateLimitExceeded", verror.RetryBackoff, "{1:}{2:} request rate limit exceeded: {3} req/s") |
| ErrTooBig = verror.Register("messenger/ifc.TooBig", verror.NoRetry, "{1:}{2:} message is too big, limit: {3}") |
| ErrTooManyHops = verror.Register("messenger/ifc.TooManyHops", verror.NoRetry, "{1:}{2:} too many hops, limit: {3}") |
| ) |
| |
| // NewErrAlreadySeen returns an error with the ErrAlreadySeen ID. |
| func NewErrAlreadySeen(ctx *context.T, Id string) error { |
| return verror.New(ErrAlreadySeen, ctx, Id) |
| } |
| |
| // NewErrBusy returns an error with the ErrBusy ID. |
| func NewErrBusy(ctx *context.T, Id string) error { |
| return verror.New(ErrBusy, ctx, Id) |
| } |
| |
| // NewErrContentMismatch returns an error with the ErrContentMismatch ID. |
| func NewErrContentMismatch(ctx *context.T) error { |
| return verror.New(ErrContentMismatch, ctx) |
| } |
| |
| // NewErrExpired returns an error with the ErrExpired ID. |
| func NewErrExpired(ctx *context.T, CreationTime time.Time, Lifespan time.Duration, Now time.Time) error { |
| return verror.New(ErrExpired, ctx, CreationTime, Lifespan, Now) |
| } |
| |
| // NewErrIncorrectOffset returns an error with the ErrIncorrectOffset ID. |
| func NewErrIncorrectOffset(ctx *context.T, Offset int64, Size int64) error { |
| return verror.New(ErrIncorrectOffset, ctx, Offset, Size) |
| } |
| |
| // NewErrInvalidSignature returns an error with the ErrInvalidSignature ID. |
| func NewErrInvalidSignature(ctx *context.T) error { |
| return verror.New(ErrInvalidSignature, ctx) |
| } |
| |
| // NewErrMessageIdCollision returns an error with the ErrMessageIdCollision ID. |
| func NewErrMessageIdCollision(ctx *context.T, Id string) error { |
| return verror.New(ErrMessageIdCollision, ctx, Id) |
| } |
| |
| // NewErrNoRoute returns an error with the ErrNoRoute ID. |
| func NewErrNoRoute(ctx *context.T, Recipient string) error { |
| return verror.New(ErrNoRoute, ctx, Recipient) |
| } |
| |
| // NewErrRateLimitExceeded returns an error with the ErrRateLimitExceeded ID. |
| func NewErrRateLimitExceeded(ctx *context.T, Limit float32) error { |
| return verror.New(ErrRateLimitExceeded, ctx, Limit) |
| } |
| |
| // NewErrTooBig returns an error with the ErrTooBig ID. |
| func NewErrTooBig(ctx *context.T, Limit int64) error { |
| return verror.New(ErrTooBig, ctx, Limit) |
| } |
| |
| // NewErrTooManyHops returns an error with the ErrTooManyHops ID. |
| func NewErrTooManyHops(ctx *context.T, Limit int32) error { |
| return verror.New(ErrTooManyHops, ctx, Limit) |
| } |
| |
| ////////////////////////////////////////////////// |
| // Interface definitions |
| |
| // MessengerClientMethods is the client interface |
| // containing Messenger methods. |
| // |
| // Messenger defines the interface to talk to nodes that can relay messages. |
| // This interface is EXPERIMENTAL and can change at any time. |
| type MessengerClientMethods interface { |
| // Diff compares the set of messages on the sender with the set of |
| // messages on the receiver. The sender streams batches of message IDs |
| // and the receiver reponds with one bool for each message ID. A true |
| // value means the receiver has the message, a false value means it |
| // doesn't. |
| Diff(*context.T, ...rpc.CallOpt) (MessengerDiffClientCall, error) |
| // Push accepts a message. The receiver may be the final recipient |
| // or a relay. If the receiver has already seen this message or |
| // if it cannot relay the message, it should return a error. |
| // |
| // The message content is streamed to the receiver. The content is |
| // opaque to everyone except the final recipient. |
| Push(_ *context.T, Msg Message, Offset int64, _ ...rpc.CallOpt) (MessengerPushClientCall, error) |
| // ResumeOffset returns the size of the partially transferred message. |
| // The caller will use it to resume the transfer. If the message doesn't |
| // exist yet, the returned offset will be 0. |
| ResumeOffset(_ *context.T, Msg Message, _ ...rpc.CallOpt) (Offset int64, _ error) |
| } |
| |
| // MessengerClientStub adds universal methods to MessengerClientMethods. |
| type MessengerClientStub interface { |
| MessengerClientMethods |
| rpc.UniversalServiceMethods |
| } |
| |
| // MessengerClient returns a client stub for Messenger. |
| func MessengerClient(name string) MessengerClientStub { |
| return implMessengerClientStub{name} |
| } |
| |
| type implMessengerClientStub struct { |
| name string |
| } |
| |
| func (c implMessengerClientStub) Diff(ctx *context.T, opts ...rpc.CallOpt) (ocall MessengerDiffClientCall, err error) { |
| var call rpc.ClientCall |
| if call, err = v23.GetClient(ctx).StartCall(ctx, c.name, "Diff", nil, opts...); err != nil { |
| return |
| } |
| ocall = &implMessengerDiffClientCall{ClientCall: call} |
| return |
| } |
| |
| func (c implMessengerClientStub) Push(ctx *context.T, i0 Message, i1 int64, opts ...rpc.CallOpt) (ocall MessengerPushClientCall, err error) { |
| var call rpc.ClientCall |
| if call, err = v23.GetClient(ctx).StartCall(ctx, c.name, "Push", []interface{}{i0, i1}, opts...); err != nil { |
| return |
| } |
| ocall = &implMessengerPushClientCall{ClientCall: call} |
| return |
| } |
| |
| func (c implMessengerClientStub) ResumeOffset(ctx *context.T, i0 Message, opts ...rpc.CallOpt) (o0 int64, err error) { |
| err = v23.GetClient(ctx).Call(ctx, c.name, "ResumeOffset", []interface{}{i0}, []interface{}{&o0}, opts...) |
| return |
| } |
| |
| // MessengerDiffClientStream is the client stream for Messenger.Diff. |
| type MessengerDiffClientStream interface { |
| // RecvStream returns the receiver side of the Messenger.Diff client stream. |
| RecvStream() interface { |
| // Advance stages an item so that it may be retrieved via Value. Returns |
| // true iff there is an item to retrieve. Advance must be called before |
| // Value is called. May block if an item is not available. |
| Advance() bool |
| // Value returns the item that was staged by Advance. May panic if Advance |
| // returned false or was not called. Never blocks. |
| Value() []bool |
| // Err returns any error encountered by Advance. Never blocks. |
| Err() error |
| } |
| // SendStream returns the send side of the Messenger.Diff client stream. |
| SendStream() interface { |
| // Send places the item onto the output stream. Returns errors |
| // encountered while sending, or if Send is called after Close or |
| // the stream has been canceled. Blocks if there is no buffer |
| // space; will unblock when buffer space is available or after |
| // the stream has been canceled. |
| Send(item []string) error |
| // Close indicates to the server that no more items will be sent; |
| // server Recv calls will receive io.EOF after all sent items. |
| // This is an optional call - e.g. a client might call Close if it |
| // needs to continue receiving items from the server after it's |
| // done sending. Returns errors encountered while closing, or if |
| // Close is called after the stream has been canceled. Like Send, |
| // blocks if there is no buffer space available. |
| Close() error |
| } |
| } |
| |
| // MessengerDiffClientCall represents the call returned from Messenger.Diff. |
| type MessengerDiffClientCall interface { |
| MessengerDiffClientStream |
| // Finish performs the equivalent of SendStream().Close, then blocks until |
| // the server is done, and returns the positional return values for the call. |
| // |
| // Finish returns immediately if the call has been canceled; depending on the |
| // timing the output could either be an error signaling cancelation, or the |
| // valid positional return values from the server. |
| // |
| // Calling Finish is mandatory for releasing stream resources, unless the call |
| // has been canceled or any of the other methods return an error. Finish should |
| // be called at most once. |
| Finish() error |
| } |
| |
| type implMessengerDiffClientCall struct { |
| rpc.ClientCall |
| valRecv []bool |
| errRecv error |
| } |
| |
| func (c *implMessengerDiffClientCall) RecvStream() interface { |
| Advance() bool |
| Value() []bool |
| Err() error |
| } { |
| return implMessengerDiffClientCallRecv{c} |
| } |
| |
| type implMessengerDiffClientCallRecv struct { |
| c *implMessengerDiffClientCall |
| } |
| |
| func (c implMessengerDiffClientCallRecv) Advance() bool { |
| c.c.errRecv = c.c.Recv(&c.c.valRecv) |
| return c.c.errRecv == nil |
| } |
| func (c implMessengerDiffClientCallRecv) Value() []bool { |
| return c.c.valRecv |
| } |
| func (c implMessengerDiffClientCallRecv) Err() error { |
| if c.c.errRecv == io.EOF { |
| return nil |
| } |
| return c.c.errRecv |
| } |
| func (c *implMessengerDiffClientCall) SendStream() interface { |
| Send(item []string) error |
| Close() error |
| } { |
| return implMessengerDiffClientCallSend{c} |
| } |
| |
| type implMessengerDiffClientCallSend struct { |
| c *implMessengerDiffClientCall |
| } |
| |
| func (c implMessengerDiffClientCallSend) Send(item []string) error { |
| return c.c.Send(item) |
| } |
| func (c implMessengerDiffClientCallSend) Close() error { |
| return c.c.CloseSend() |
| } |
| func (c *implMessengerDiffClientCall) Finish() (err error) { |
| err = c.ClientCall.Finish() |
| return |
| } |
| |
| // MessengerPushClientStream is the client stream for Messenger.Push. |
| type MessengerPushClientStream interface { |
| // SendStream returns the send side of the Messenger.Push client stream. |
| SendStream() interface { |
| // Send places the item onto the output stream. Returns errors |
| // encountered while sending, or if Send is called after Close or |
| // the stream has been canceled. Blocks if there is no buffer |
| // space; will unblock when buffer space is available or after |
| // the stream has been canceled. |
| Send(item []byte) error |
| // Close indicates to the server that no more items will be sent; |
| // server Recv calls will receive io.EOF after all sent items. |
| // This is an optional call - e.g. a client might call Close if it |
| // needs to continue receiving items from the server after it's |
| // done sending. Returns errors encountered while closing, or if |
| // Close is called after the stream has been canceled. Like Send, |
| // blocks if there is no buffer space available. |
| Close() error |
| } |
| } |
| |
| // MessengerPushClientCall represents the call returned from Messenger.Push. |
| type MessengerPushClientCall interface { |
| MessengerPushClientStream |
| // Finish performs the equivalent of SendStream().Close, then blocks until |
| // the server is done, and returns the positional return values for the call. |
| // |
| // Finish returns immediately if the call has been canceled; depending on the |
| // timing the output could either be an error signaling cancelation, or the |
| // valid positional return values from the server. |
| // |
| // Calling Finish is mandatory for releasing stream resources, unless the call |
| // has been canceled or any of the other methods return an error. Finish should |
| // be called at most once. |
| Finish() error |
| } |
| |
| type implMessengerPushClientCall struct { |
| rpc.ClientCall |
| } |
| |
| func (c *implMessengerPushClientCall) SendStream() interface { |
| Send(item []byte) error |
| Close() error |
| } { |
| return implMessengerPushClientCallSend{c} |
| } |
| |
| type implMessengerPushClientCallSend struct { |
| c *implMessengerPushClientCall |
| } |
| |
| func (c implMessengerPushClientCallSend) Send(item []byte) error { |
| return c.c.Send(item) |
| } |
| func (c implMessengerPushClientCallSend) Close() error { |
| return c.c.CloseSend() |
| } |
| func (c *implMessengerPushClientCall) Finish() (err error) { |
| err = c.ClientCall.Finish() |
| return |
| } |
| |
| // MessengerServerMethods is the interface a server writer |
| // implements for Messenger. |
| // |
| // Messenger defines the interface to talk to nodes that can relay messages. |
| // This interface is EXPERIMENTAL and can change at any time. |
| type MessengerServerMethods interface { |
| // Diff compares the set of messages on the sender with the set of |
| // messages on the receiver. The sender streams batches of message IDs |
| // and the receiver reponds with one bool for each message ID. A true |
| // value means the receiver has the message, a false value means it |
| // doesn't. |
| Diff(*context.T, MessengerDiffServerCall) error |
| // Push accepts a message. The receiver may be the final recipient |
| // or a relay. If the receiver has already seen this message or |
| // if it cannot relay the message, it should return a error. |
| // |
| // The message content is streamed to the receiver. The content is |
| // opaque to everyone except the final recipient. |
| Push(_ *context.T, _ MessengerPushServerCall, Msg Message, Offset int64) error |
| // ResumeOffset returns the size of the partially transferred message. |
| // The caller will use it to resume the transfer. If the message doesn't |
| // exist yet, the returned offset will be 0. |
| ResumeOffset(_ *context.T, _ rpc.ServerCall, Msg Message) (Offset int64, _ error) |
| } |
| |
| // MessengerServerStubMethods is the server interface containing |
| // Messenger methods, as expected by rpc.Server. |
| // The only difference between this interface and MessengerServerMethods |
| // is the streaming methods. |
| type MessengerServerStubMethods interface { |
| // Diff compares the set of messages on the sender with the set of |
| // messages on the receiver. The sender streams batches of message IDs |
| // and the receiver reponds with one bool for each message ID. A true |
| // value means the receiver has the message, a false value means it |
| // doesn't. |
| Diff(*context.T, *MessengerDiffServerCallStub) error |
| // Push accepts a message. The receiver may be the final recipient |
| // or a relay. If the receiver has already seen this message or |
| // if it cannot relay the message, it should return a error. |
| // |
| // The message content is streamed to the receiver. The content is |
| // opaque to everyone except the final recipient. |
| Push(_ *context.T, _ *MessengerPushServerCallStub, Msg Message, Offset int64) error |
| // ResumeOffset returns the size of the partially transferred message. |
| // The caller will use it to resume the transfer. If the message doesn't |
| // exist yet, the returned offset will be 0. |
| ResumeOffset(_ *context.T, _ rpc.ServerCall, Msg Message) (Offset int64, _ error) |
| } |
| |
| // MessengerServerStub adds universal methods to MessengerServerStubMethods. |
| type MessengerServerStub interface { |
| MessengerServerStubMethods |
| // Describe the Messenger interfaces. |
| Describe__() []rpc.InterfaceDesc |
| } |
| |
| // MessengerServer returns a server stub for Messenger. |
| // It converts an implementation of MessengerServerMethods into |
| // an object that may be used by rpc.Server. |
| func MessengerServer(impl MessengerServerMethods) MessengerServerStub { |
| stub := implMessengerServerStub{ |
| 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 implMessengerServerStub struct { |
| impl MessengerServerMethods |
| gs *rpc.GlobState |
| } |
| |
| func (s implMessengerServerStub) Diff(ctx *context.T, call *MessengerDiffServerCallStub) error { |
| return s.impl.Diff(ctx, call) |
| } |
| |
| func (s implMessengerServerStub) Push(ctx *context.T, call *MessengerPushServerCallStub, i0 Message, i1 int64) error { |
| return s.impl.Push(ctx, call, i0, i1) |
| } |
| |
| func (s implMessengerServerStub) ResumeOffset(ctx *context.T, call rpc.ServerCall, i0 Message) (int64, error) { |
| return s.impl.ResumeOffset(ctx, call, i0) |
| } |
| |
| func (s implMessengerServerStub) Globber() *rpc.GlobState { |
| return s.gs |
| } |
| |
| func (s implMessengerServerStub) Describe__() []rpc.InterfaceDesc { |
| return []rpc.InterfaceDesc{MessengerDesc} |
| } |
| |
| // MessengerDesc describes the Messenger interface. |
| var MessengerDesc rpc.InterfaceDesc = descMessenger |
| |
| // descMessenger hides the desc to keep godoc clean. |
| var descMessenger = rpc.InterfaceDesc{ |
| Name: "Messenger", |
| PkgPath: "messenger/ifc", |
| Doc: "// Messenger defines the interface to talk to nodes that can relay messages.\n// This interface is EXPERIMENTAL and can change at any time.", |
| Methods: []rpc.MethodDesc{ |
| { |
| Name: "Diff", |
| Doc: "// Diff compares the set of messages on the sender with the set of\n// messages on the receiver. The sender streams batches of message IDs\n// and the receiver reponds with one bool for each message ID. A true\n// value means the receiver has the message, a false value means it\n// doesn't.", |
| }, |
| { |
| Name: "Push", |
| Doc: "// Push accepts a message. The receiver may be the final recipient\n// or a relay. If the receiver has already seen this message or\n// if it cannot relay the message, it should return a error.\n//\n// The message content is streamed to the receiver. The content is\n// opaque to everyone except the final recipient.", |
| InArgs: []rpc.ArgDesc{ |
| {"Msg", ``}, // Message |
| {"Offset", ``}, // int64 |
| }, |
| }, |
| { |
| Name: "ResumeOffset", |
| Doc: "// ResumeOffset returns the size of the partially transferred message.\n// The caller will use it to resume the transfer. If the message doesn't\n// exist yet, the returned offset will be 0.", |
| InArgs: []rpc.ArgDesc{ |
| {"Msg", ``}, // Message |
| }, |
| OutArgs: []rpc.ArgDesc{ |
| {"Offset", ``}, // int64 |
| }, |
| }, |
| }, |
| } |
| |
| // MessengerDiffServerStream is the server stream for Messenger.Diff. |
| type MessengerDiffServerStream interface { |
| // RecvStream returns the receiver side of the Messenger.Diff server stream. |
| RecvStream() interface { |
| // Advance stages an item so that it may be retrieved via Value. Returns |
| // true iff there is an item to retrieve. Advance must be called before |
| // Value is called. May block if an item is not available. |
| Advance() bool |
| // Value returns the item that was staged by Advance. May panic if Advance |
| // returned false or was not called. Never blocks. |
| Value() []string |
| // Err returns any error encountered by Advance. Never blocks. |
| Err() error |
| } |
| // SendStream returns the send side of the Messenger.Diff server stream. |
| SendStream() interface { |
| // Send places the item onto the output stream. Returns errors encountered |
| // while sending. Blocks if there is no buffer space; will unblock when |
| // buffer space is available. |
| Send(item []bool) error |
| } |
| } |
| |
| // MessengerDiffServerCall represents the context passed to Messenger.Diff. |
| type MessengerDiffServerCall interface { |
| rpc.ServerCall |
| MessengerDiffServerStream |
| } |
| |
| // MessengerDiffServerCallStub is a wrapper that converts rpc.StreamServerCall into |
| // a typesafe stub that implements MessengerDiffServerCall. |
| type MessengerDiffServerCallStub struct { |
| rpc.StreamServerCall |
| valRecv []string |
| errRecv error |
| } |
| |
| // Init initializes MessengerDiffServerCallStub from rpc.StreamServerCall. |
| func (s *MessengerDiffServerCallStub) Init(call rpc.StreamServerCall) { |
| s.StreamServerCall = call |
| } |
| |
| // RecvStream returns the receiver side of the Messenger.Diff server stream. |
| func (s *MessengerDiffServerCallStub) RecvStream() interface { |
| Advance() bool |
| Value() []string |
| Err() error |
| } { |
| return implMessengerDiffServerCallRecv{s} |
| } |
| |
| type implMessengerDiffServerCallRecv struct { |
| s *MessengerDiffServerCallStub |
| } |
| |
| func (s implMessengerDiffServerCallRecv) Advance() bool { |
| s.s.errRecv = s.s.Recv(&s.s.valRecv) |
| return s.s.errRecv == nil |
| } |
| func (s implMessengerDiffServerCallRecv) Value() []string { |
| return s.s.valRecv |
| } |
| func (s implMessengerDiffServerCallRecv) Err() error { |
| if s.s.errRecv == io.EOF { |
| return nil |
| } |
| return s.s.errRecv |
| } |
| |
| // SendStream returns the send side of the Messenger.Diff server stream. |
| func (s *MessengerDiffServerCallStub) SendStream() interface { |
| Send(item []bool) error |
| } { |
| return implMessengerDiffServerCallSend{s} |
| } |
| |
| type implMessengerDiffServerCallSend struct { |
| s *MessengerDiffServerCallStub |
| } |
| |
| func (s implMessengerDiffServerCallSend) Send(item []bool) error { |
| return s.s.Send(item) |
| } |
| |
| // MessengerPushServerStream is the server stream for Messenger.Push. |
| type MessengerPushServerStream interface { |
| // RecvStream returns the receiver side of the Messenger.Push server stream. |
| RecvStream() interface { |
| // Advance stages an item so that it may be retrieved via Value. Returns |
| // true iff there is an item to retrieve. Advance must be called before |
| // Value is called. May block if an item is not available. |
| Advance() bool |
| // Value returns the item that was staged by Advance. May panic if Advance |
| // returned false or was not called. Never blocks. |
| Value() []byte |
| // Err returns any error encountered by Advance. Never blocks. |
| Err() error |
| } |
| } |
| |
| // MessengerPushServerCall represents the context passed to Messenger.Push. |
| type MessengerPushServerCall interface { |
| rpc.ServerCall |
| MessengerPushServerStream |
| } |
| |
| // MessengerPushServerCallStub is a wrapper that converts rpc.StreamServerCall into |
| // a typesafe stub that implements MessengerPushServerCall. |
| type MessengerPushServerCallStub struct { |
| rpc.StreamServerCall |
| valRecv []byte |
| errRecv error |
| } |
| |
| // Init initializes MessengerPushServerCallStub from rpc.StreamServerCall. |
| func (s *MessengerPushServerCallStub) Init(call rpc.StreamServerCall) { |
| s.StreamServerCall = call |
| } |
| |
| // RecvStream returns the receiver side of the Messenger.Push server stream. |
| func (s *MessengerPushServerCallStub) RecvStream() interface { |
| Advance() bool |
| Value() []byte |
| Err() error |
| } { |
| return implMessengerPushServerCallRecv{s} |
| } |
| |
| type implMessengerPushServerCallRecv struct { |
| s *MessengerPushServerCallStub |
| } |
| |
| func (s implMessengerPushServerCallRecv) Advance() bool { |
| s.s.errRecv = s.s.Recv(&s.s.valRecv) |
| return s.s.errRecv == nil |
| } |
| func (s implMessengerPushServerCallRecv) Value() []byte { |
| return s.s.valRecv |
| } |
| func (s implMessengerPushServerCallRecv) Err() error { |
| if s.s.errRecv == io.EOF { |
| return nil |
| } |
| return s.s.errRecv |
| } |
| |
| // MessageRepositoryClientMethods is the client interface |
| // containing MessageRepository methods. |
| // |
| // MessageRepository defines the interface to talk to a node that holds |
| // messages. |
| // This interface is EXPERIMENTAL and can change at any time. |
| type MessageRepositoryClientMethods interface { |
| // Manifest shows all messages in the receiver's repository. |
| Manifest(*context.T, ...rpc.CallOpt) (MessageRepositoryManifestClientCall, error) |
| // Pull retrieves the message with the given ID. The message content |
| // is streamed to the caller. |
| Pull(_ *context.T, Id string, Offset int64, _ ...rpc.CallOpt) (MessageRepositoryPullClientCall, error) |
| } |
| |
| // MessageRepositoryClientStub adds universal methods to MessageRepositoryClientMethods. |
| type MessageRepositoryClientStub interface { |
| MessageRepositoryClientMethods |
| rpc.UniversalServiceMethods |
| } |
| |
| // MessageRepositoryClient returns a client stub for MessageRepository. |
| func MessageRepositoryClient(name string) MessageRepositoryClientStub { |
| return implMessageRepositoryClientStub{name} |
| } |
| |
| type implMessageRepositoryClientStub struct { |
| name string |
| } |
| |
| func (c implMessageRepositoryClientStub) Manifest(ctx *context.T, opts ...rpc.CallOpt) (ocall MessageRepositoryManifestClientCall, err error) { |
| var call rpc.ClientCall |
| if call, err = v23.GetClient(ctx).StartCall(ctx, c.name, "Manifest", nil, opts...); err != nil { |
| return |
| } |
| ocall = &implMessageRepositoryManifestClientCall{ClientCall: call} |
| return |
| } |
| |
| func (c implMessageRepositoryClientStub) Pull(ctx *context.T, i0 string, i1 int64, opts ...rpc.CallOpt) (ocall MessageRepositoryPullClientCall, err error) { |
| var call rpc.ClientCall |
| if call, err = v23.GetClient(ctx).StartCall(ctx, c.name, "Pull", []interface{}{i0, i1}, opts...); err != nil { |
| return |
| } |
| ocall = &implMessageRepositoryPullClientCall{ClientCall: call} |
| return |
| } |
| |
| // MessageRepositoryManifestClientStream is the client stream for MessageRepository.Manifest. |
| type MessageRepositoryManifestClientStream interface { |
| // RecvStream returns the receiver side of the MessageRepository.Manifest client stream. |
| RecvStream() interface { |
| // Advance stages an item so that it may be retrieved via Value. Returns |
| // true iff there is an item to retrieve. Advance must be called before |
| // Value is called. May block if an item is not available. |
| Advance() bool |
| // Value returns the item that was staged by Advance. May panic if Advance |
| // returned false or was not called. Never blocks. |
| Value() Message |
| // Err returns any error encountered by Advance. Never blocks. |
| Err() error |
| } |
| } |
| |
| // MessageRepositoryManifestClientCall represents the call returned from MessageRepository.Manifest. |
| type MessageRepositoryManifestClientCall interface { |
| MessageRepositoryManifestClientStream |
| // Finish blocks until the server is done, and returns the positional return |
| // values for call. |
| // |
| // Finish returns immediately if the call has been canceled; depending on the |
| // timing the output could either be an error signaling cancelation, or the |
| // valid positional return values from the server. |
| // |
| // Calling Finish is mandatory for releasing stream resources, unless the call |
| // has been canceled or any of the other methods return an error. Finish should |
| // be called at most once. |
| Finish() error |
| } |
| |
| type implMessageRepositoryManifestClientCall struct { |
| rpc.ClientCall |
| valRecv Message |
| errRecv error |
| } |
| |
| func (c *implMessageRepositoryManifestClientCall) RecvStream() interface { |
| Advance() bool |
| Value() Message |
| Err() error |
| } { |
| return implMessageRepositoryManifestClientCallRecv{c} |
| } |
| |
| type implMessageRepositoryManifestClientCallRecv struct { |
| c *implMessageRepositoryManifestClientCall |
| } |
| |
| func (c implMessageRepositoryManifestClientCallRecv) Advance() bool { |
| c.c.valRecv = Message{} |
| c.c.errRecv = c.c.Recv(&c.c.valRecv) |
| return c.c.errRecv == nil |
| } |
| func (c implMessageRepositoryManifestClientCallRecv) Value() Message { |
| return c.c.valRecv |
| } |
| func (c implMessageRepositoryManifestClientCallRecv) Err() error { |
| if c.c.errRecv == io.EOF { |
| return nil |
| } |
| return c.c.errRecv |
| } |
| func (c *implMessageRepositoryManifestClientCall) Finish() (err error) { |
| err = c.ClientCall.Finish() |
| return |
| } |
| |
| // MessageRepositoryPullClientStream is the client stream for MessageRepository.Pull. |
| type MessageRepositoryPullClientStream interface { |
| // RecvStream returns the receiver side of the MessageRepository.Pull client stream. |
| RecvStream() interface { |
| // Advance stages an item so that it may be retrieved via Value. Returns |
| // true iff there is an item to retrieve. Advance must be called before |
| // Value is called. May block if an item is not available. |
| Advance() bool |
| // Value returns the item that was staged by Advance. May panic if Advance |
| // returned false or was not called. Never blocks. |
| Value() []byte |
| // Err returns any error encountered by Advance. Never blocks. |
| Err() error |
| } |
| } |
| |
| // MessageRepositoryPullClientCall represents the call returned from MessageRepository.Pull. |
| type MessageRepositoryPullClientCall interface { |
| MessageRepositoryPullClientStream |
| // Finish blocks until the server is done, and returns the positional return |
| // values for call. |
| // |
| // Finish returns immediately if the call has been canceled; depending on the |
| // timing the output could either be an error signaling cancelation, or the |
| // valid positional return values from the server. |
| // |
| // Calling Finish is mandatory for releasing stream resources, unless the call |
| // has been canceled or any of the other methods return an error. Finish should |
| // be called at most once. |
| Finish() (Message, error) |
| } |
| |
| type implMessageRepositoryPullClientCall struct { |
| rpc.ClientCall |
| valRecv []byte |
| errRecv error |
| } |
| |
| func (c *implMessageRepositoryPullClientCall) RecvStream() interface { |
| Advance() bool |
| Value() []byte |
| Err() error |
| } { |
| return implMessageRepositoryPullClientCallRecv{c} |
| } |
| |
| type implMessageRepositoryPullClientCallRecv struct { |
| c *implMessageRepositoryPullClientCall |
| } |
| |
| func (c implMessageRepositoryPullClientCallRecv) Advance() bool { |
| c.c.errRecv = c.c.Recv(&c.c.valRecv) |
| return c.c.errRecv == nil |
| } |
| func (c implMessageRepositoryPullClientCallRecv) Value() []byte { |
| return c.c.valRecv |
| } |
| func (c implMessageRepositoryPullClientCallRecv) Err() error { |
| if c.c.errRecv == io.EOF { |
| return nil |
| } |
| return c.c.errRecv |
| } |
| func (c *implMessageRepositoryPullClientCall) Finish() (o0 Message, err error) { |
| err = c.ClientCall.Finish(&o0) |
| return |
| } |
| |
| // MessageRepositoryServerMethods is the interface a server writer |
| // implements for MessageRepository. |
| // |
| // MessageRepository defines the interface to talk to a node that holds |
| // messages. |
| // This interface is EXPERIMENTAL and can change at any time. |
| type MessageRepositoryServerMethods interface { |
| // Manifest shows all messages in the receiver's repository. |
| Manifest(*context.T, MessageRepositoryManifestServerCall) error |
| // Pull retrieves the message with the given ID. The message content |
| // is streamed to the caller. |
| Pull(_ *context.T, _ MessageRepositoryPullServerCall, Id string, Offset int64) (Message, error) |
| } |
| |
| // MessageRepositoryServerStubMethods is the server interface containing |
| // MessageRepository methods, as expected by rpc.Server. |
| // The only difference between this interface and MessageRepositoryServerMethods |
| // is the streaming methods. |
| type MessageRepositoryServerStubMethods interface { |
| // Manifest shows all messages in the receiver's repository. |
| Manifest(*context.T, *MessageRepositoryManifestServerCallStub) error |
| // Pull retrieves the message with the given ID. The message content |
| // is streamed to the caller. |
| Pull(_ *context.T, _ *MessageRepositoryPullServerCallStub, Id string, Offset int64) (Message, error) |
| } |
| |
| // MessageRepositoryServerStub adds universal methods to MessageRepositoryServerStubMethods. |
| type MessageRepositoryServerStub interface { |
| MessageRepositoryServerStubMethods |
| // Describe the MessageRepository interfaces. |
| Describe__() []rpc.InterfaceDesc |
| } |
| |
| // MessageRepositoryServer returns a server stub for MessageRepository. |
| // It converts an implementation of MessageRepositoryServerMethods into |
| // an object that may be used by rpc.Server. |
| func MessageRepositoryServer(impl MessageRepositoryServerMethods) MessageRepositoryServerStub { |
| stub := implMessageRepositoryServerStub{ |
| 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 implMessageRepositoryServerStub struct { |
| impl MessageRepositoryServerMethods |
| gs *rpc.GlobState |
| } |
| |
| func (s implMessageRepositoryServerStub) Manifest(ctx *context.T, call *MessageRepositoryManifestServerCallStub) error { |
| return s.impl.Manifest(ctx, call) |
| } |
| |
| func (s implMessageRepositoryServerStub) Pull(ctx *context.T, call *MessageRepositoryPullServerCallStub, i0 string, i1 int64) (Message, error) { |
| return s.impl.Pull(ctx, call, i0, i1) |
| } |
| |
| func (s implMessageRepositoryServerStub) Globber() *rpc.GlobState { |
| return s.gs |
| } |
| |
| func (s implMessageRepositoryServerStub) Describe__() []rpc.InterfaceDesc { |
| return []rpc.InterfaceDesc{MessageRepositoryDesc} |
| } |
| |
| // MessageRepositoryDesc describes the MessageRepository interface. |
| var MessageRepositoryDesc rpc.InterfaceDesc = descMessageRepository |
| |
| // descMessageRepository hides the desc to keep godoc clean. |
| var descMessageRepository = rpc.InterfaceDesc{ |
| Name: "MessageRepository", |
| PkgPath: "messenger/ifc", |
| Doc: "// MessageRepository defines the interface to talk to a node that holds\n// messages.\n// This interface is EXPERIMENTAL and can change at any time.", |
| Methods: []rpc.MethodDesc{ |
| { |
| Name: "Manifest", |
| Doc: "// Manifest shows all messages in the receiver's repository.", |
| }, |
| { |
| Name: "Pull", |
| Doc: "// Pull retrieves the message with the given ID. The message content\n// is streamed to the caller.", |
| InArgs: []rpc.ArgDesc{ |
| {"Id", ``}, // string |
| {"Offset", ``}, // int64 |
| }, |
| OutArgs: []rpc.ArgDesc{ |
| {"", ``}, // Message |
| }, |
| }, |
| }, |
| } |
| |
| // MessageRepositoryManifestServerStream is the server stream for MessageRepository.Manifest. |
| type MessageRepositoryManifestServerStream interface { |
| // SendStream returns the send side of the MessageRepository.Manifest server stream. |
| SendStream() interface { |
| // Send places the item onto the output stream. Returns errors encountered |
| // while sending. Blocks if there is no buffer space; will unblock when |
| // buffer space is available. |
| Send(item Message) error |
| } |
| } |
| |
| // MessageRepositoryManifestServerCall represents the context passed to MessageRepository.Manifest. |
| type MessageRepositoryManifestServerCall interface { |
| rpc.ServerCall |
| MessageRepositoryManifestServerStream |
| } |
| |
| // MessageRepositoryManifestServerCallStub is a wrapper that converts rpc.StreamServerCall into |
| // a typesafe stub that implements MessageRepositoryManifestServerCall. |
| type MessageRepositoryManifestServerCallStub struct { |
| rpc.StreamServerCall |
| } |
| |
| // Init initializes MessageRepositoryManifestServerCallStub from rpc.StreamServerCall. |
| func (s *MessageRepositoryManifestServerCallStub) Init(call rpc.StreamServerCall) { |
| s.StreamServerCall = call |
| } |
| |
| // SendStream returns the send side of the MessageRepository.Manifest server stream. |
| func (s *MessageRepositoryManifestServerCallStub) SendStream() interface { |
| Send(item Message) error |
| } { |
| return implMessageRepositoryManifestServerCallSend{s} |
| } |
| |
| type implMessageRepositoryManifestServerCallSend struct { |
| s *MessageRepositoryManifestServerCallStub |
| } |
| |
| func (s implMessageRepositoryManifestServerCallSend) Send(item Message) error { |
| return s.s.Send(item) |
| } |
| |
| // MessageRepositoryPullServerStream is the server stream for MessageRepository.Pull. |
| type MessageRepositoryPullServerStream interface { |
| // SendStream returns the send side of the MessageRepository.Pull server stream. |
| SendStream() interface { |
| // Send places the item onto the output stream. Returns errors encountered |
| // while sending. Blocks if there is no buffer space; will unblock when |
| // buffer space is available. |
| Send(item []byte) error |
| } |
| } |
| |
| // MessageRepositoryPullServerCall represents the context passed to MessageRepository.Pull. |
| type MessageRepositoryPullServerCall interface { |
| rpc.ServerCall |
| MessageRepositoryPullServerStream |
| } |
| |
| // MessageRepositoryPullServerCallStub is a wrapper that converts rpc.StreamServerCall into |
| // a typesafe stub that implements MessageRepositoryPullServerCall. |
| type MessageRepositoryPullServerCallStub struct { |
| rpc.StreamServerCall |
| } |
| |
| // Init initializes MessageRepositoryPullServerCallStub from rpc.StreamServerCall. |
| func (s *MessageRepositoryPullServerCallStub) Init(call rpc.StreamServerCall) { |
| s.StreamServerCall = call |
| } |
| |
| // SendStream returns the send side of the MessageRepository.Pull server stream. |
| func (s *MessageRepositoryPullServerCallStub) SendStream() interface { |
| Send(item []byte) error |
| } { |
| return implMessageRepositoryPullServerCallSend{s} |
| } |
| |
| type implMessageRepositoryPullServerCallSend struct { |
| s *MessageRepositoryPullServerCallStub |
| } |
| |
| func (s implMessageRepositoryPullServerCallSend) Send(item []byte) error { |
| return s.s.Send(item) |
| } |
| |
| // MessengerRepositoryClientMethods is the client interface |
| // containing MessengerRepository methods. |
| // |
| // MessengerRepository combines the Messenger and MessageRepository interfaces. |
| type MessengerRepositoryClientMethods interface { |
| // Messenger defines the interface to talk to nodes that can relay messages. |
| // This interface is EXPERIMENTAL and can change at any time. |
| MessengerClientMethods |
| // MessageRepository defines the interface to talk to a node that holds |
| // messages. |
| // This interface is EXPERIMENTAL and can change at any time. |
| MessageRepositoryClientMethods |
| } |
| |
| // MessengerRepositoryClientStub adds universal methods to MessengerRepositoryClientMethods. |
| type MessengerRepositoryClientStub interface { |
| MessengerRepositoryClientMethods |
| rpc.UniversalServiceMethods |
| } |
| |
| // MessengerRepositoryClient returns a client stub for MessengerRepository. |
| func MessengerRepositoryClient(name string) MessengerRepositoryClientStub { |
| return implMessengerRepositoryClientStub{name, MessengerClient(name), MessageRepositoryClient(name)} |
| } |
| |
| type implMessengerRepositoryClientStub struct { |
| name string |
| |
| MessengerClientStub |
| MessageRepositoryClientStub |
| } |
| |
| // MessengerRepositoryServerMethods is the interface a server writer |
| // implements for MessengerRepository. |
| // |
| // MessengerRepository combines the Messenger and MessageRepository interfaces. |
| type MessengerRepositoryServerMethods interface { |
| // Messenger defines the interface to talk to nodes that can relay messages. |
| // This interface is EXPERIMENTAL and can change at any time. |
| MessengerServerMethods |
| // MessageRepository defines the interface to talk to a node that holds |
| // messages. |
| // This interface is EXPERIMENTAL and can change at any time. |
| MessageRepositoryServerMethods |
| } |
| |
| // MessengerRepositoryServerStubMethods is the server interface containing |
| // MessengerRepository methods, as expected by rpc.Server. |
| // The only difference between this interface and MessengerRepositoryServerMethods |
| // is the streaming methods. |
| type MessengerRepositoryServerStubMethods interface { |
| // Messenger defines the interface to talk to nodes that can relay messages. |
| // This interface is EXPERIMENTAL and can change at any time. |
| MessengerServerStubMethods |
| // MessageRepository defines the interface to talk to a node that holds |
| // messages. |
| // This interface is EXPERIMENTAL and can change at any time. |
| MessageRepositoryServerStubMethods |
| } |
| |
| // MessengerRepositoryServerStub adds universal methods to MessengerRepositoryServerStubMethods. |
| type MessengerRepositoryServerStub interface { |
| MessengerRepositoryServerStubMethods |
| // Describe the MessengerRepository interfaces. |
| Describe__() []rpc.InterfaceDesc |
| } |
| |
| // MessengerRepositoryServer returns a server stub for MessengerRepository. |
| // It converts an implementation of MessengerRepositoryServerMethods into |
| // an object that may be used by rpc.Server. |
| func MessengerRepositoryServer(impl MessengerRepositoryServerMethods) MessengerRepositoryServerStub { |
| stub := implMessengerRepositoryServerStub{ |
| impl: impl, |
| MessengerServerStub: MessengerServer(impl), |
| MessageRepositoryServerStub: MessageRepositoryServer(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 implMessengerRepositoryServerStub struct { |
| impl MessengerRepositoryServerMethods |
| MessengerServerStub |
| MessageRepositoryServerStub |
| gs *rpc.GlobState |
| } |
| |
| func (s implMessengerRepositoryServerStub) Globber() *rpc.GlobState { |
| return s.gs |
| } |
| |
| func (s implMessengerRepositoryServerStub) Describe__() []rpc.InterfaceDesc { |
| return []rpc.InterfaceDesc{MessengerRepositoryDesc, MessengerDesc, MessageRepositoryDesc} |
| } |
| |
| // MessengerRepositoryDesc describes the MessengerRepository interface. |
| var MessengerRepositoryDesc rpc.InterfaceDesc = descMessengerRepository |
| |
| // descMessengerRepository hides the desc to keep godoc clean. |
| var descMessengerRepository = rpc.InterfaceDesc{ |
| Name: "MessengerRepository", |
| PkgPath: "messenger/ifc", |
| Doc: "// MessengerRepository combines the Messenger and MessageRepository interfaces.", |
| Embeds: []rpc.EmbedDesc{ |
| {"Messenger", "messenger/ifc", "// Messenger defines the interface to talk to nodes that can relay messages.\n// This interface is EXPERIMENTAL and can change at any time."}, |
| {"MessageRepository", "messenger/ifc", "// MessageRepository defines the interface to talk to a node that holds\n// messages.\n// This interface is EXPERIMENTAL and can change at any time."}, |
| }, |
| } |
| |
| // Hold type definitions in package-level variables, for better performance. |
| var ( |
| __VDLType_struct_1 *vdl.Type |
| __VDLType_list_2 *vdl.Type |
| __VDLType_struct_3 *vdl.Type |
| __VDLType_map_4 *vdl.Type |
| __VDLType_struct_5 *vdl.Type |
| __VDLType_struct_6 *vdl.Type |
| __VDLType_struct_7 *vdl.Type |
| __VDLType_list_8 *vdl.Type |
| __VDLType_union_9 *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((*Message)(nil)) |
| |
| // Initialize type definitions. |
| __VDLType_struct_1 = vdl.TypeOf((*Message)(nil)).Elem() |
| __VDLType_list_2 = vdl.TypeOf((*[]string)(nil)) |
| __VDLType_struct_3 = vdl.TypeOf((*security.WireBlessings)(nil)).Elem() |
| __VDLType_map_4 = vdl.TypeOf((*map[string]security.Discharge)(nil)) |
| __VDLType_struct_5 = vdl.TypeOf((*security.Signature)(nil)).Elem() |
| __VDLType_struct_6 = vdl.TypeOf((*vdltime.Time)(nil)).Elem() |
| __VDLType_struct_7 = vdl.TypeOf((*vdltime.Duration)(nil)).Elem() |
| __VDLType_list_8 = vdl.TypeOf((*[]byte)(nil)) |
| __VDLType_union_9 = vdl.TypeOf((*security.WireDischarge)(nil)) |
| |
| // Set error format strings. |
| i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrAlreadySeen.ID), "{1:}{2:} message id already seen: {3}") |
| i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrBusy.ID), "{1:}{2:} message is already opened") |
| i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrContentMismatch.ID), "{1:}{2:} the sha256 hash doesn't match the message content") |
| i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrExpired.ID), "{1:}{2:} message lifespan expired: {3} + {4} < {5}") |
| i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrIncorrectOffset.ID), "{1:}{2:} the specified file offset is incorrect ({3} != {4})") |
| i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrInvalidSignature.ID), "{1:}{2:} message signature is invalid") |
| i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrMessageIdCollision.ID), "{1:}{2:} message id already seen with different content: {3}") |
| i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrNoRoute.ID), "{1:}{2:} no route for recipient: {3}") |
| i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrRateLimitExceeded.ID), "{1:}{2:} request rate limit exceeded: {3} req/s") |
| i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrTooBig.ID), "{1:}{2:} message is too big, limit: {3}") |
| i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrTooManyHops.ID), "{1:}{2:} too many hops, limit: {3}") |
| |
| return struct{}{} |
| } |