Merge "veyron/examples/pipetobrowser: Search, filter and sort for the Git Status plugin"
diff --git a/examples/boxes/android/src/boxesp2p/main.go b/examples/boxes/android/src/boxesp2p/main.go
index f2a1afe..b157517 100644
--- a/examples/boxes/android/src/boxesp2p/main.go
+++ b/examples/boxes/android/src/boxesp2p/main.go
@@ -87,10 +87,17 @@
jMID C.jmethodID
}
+type boxesDispatcher struct {
+ drawAuth, syncAuth security.Authorizer
+ drawServer, syncServer ipc.Invoker
+ storeDispatcher ipc.Dispatcher
+}
+
type goState struct {
runtime veyron2.Runtime
store *storage.Server
ipc ipc.Server
+ disp boxesDispatcher
drawStream boxes.DrawInterfaceServiceDrawStream
signalling boxes.BoxSignalling
boxList chan boxes.Box
@@ -130,6 +137,16 @@
C.callMethod(env, jni.jObj, jni.jMID, jBoxId, &jPoints[0])
}
+func (d *boxesDispatcher) Lookup(suffix string) (ipc.Invoker, security.Authorizer, error) {
+ if strings.HasSuffix(suffix, "draw") {
+ return d.drawServer, d.drawAuth, nil
+ }
+ if strings.HasSuffix(suffix, "sync") {
+ return d.syncServer, d.syncAuth, nil
+ }
+ return d.storeDispatcher.Lookup(suffix)
+}
+
func (gs *goState) SyncBoxes(context ipc.ServerContext) error {
// Get the endpoint of the remote process
endPt, err := inaming.NewEndpoint(context.RemoteEndpoint().String())
@@ -228,18 +245,15 @@
func (gs *goState) registerAsPeer() {
auth := security.NewACLAuthorizer(security.ACL{security.AllPrincipals: security.LabelSet(security.AdminLabel)})
- srv, err := gs.runtime.NewServer()
- if err != nil {
- panic(fmt.Errorf("Failed runtime.NewServer:%v", err))
- }
- drawServer := boxes.NewServerDrawInterface(gs)
- if err := srv.Register("draw", ipc.SoloDispatcher(drawServer, auth)); err != nil {
- panic(fmt.Errorf("Failed Register:%v", err))
- }
- endPt, err := srv.Listen("tcp", gs.myIPAddr+drawServicePort)
+ gs.disp.drawAuth = auth
+ gs.disp.drawServer = ipc.ReflectInvoker(boxes.NewServerDrawInterface(gs))
+ endPt, err := gs.ipc.Listen("tcp", gs.myIPAddr+drawServicePort)
if err != nil {
panic(fmt.Errorf("Failed to Listen:%v", err))
}
+ if err := gs.ipc.Serve("", &gs.disp); err != nil {
+ panic(fmt.Errorf("Failed Register:%v", err))
+ }
if err := gs.signalling.Add(gs.runtime.TODOContext(), endPt.String()); err != nil {
panic(fmt.Errorf("Failed to Add endpoint to signalling server:%v", err))
}
@@ -319,28 +333,30 @@
panic(fmt.Errorf("LoadACL failed:%v", err))
}
auth := security.NewACLAuthorizer(acl)
-
- // Register the services
- if err = gs.ipc.Register("", storage.NewStoreDispatcher(gs.store, auth)); err != nil {
- panic(fmt.Errorf("s.Register(store) failed:%v", err))
- }
+ gs.disp.storeDispatcher = storage.NewStoreDispatcher(gs.store, auth)
// Create an endpoint and start listening
if _, err = gs.ipc.Listen("tcp", gs.myIPAddr+storeServicePort); err != nil {
panic(fmt.Errorf("s.Listen() failed:%v", err))
}
+ // Register the services
+ if err = gs.ipc.Serve("", &gs.disp); err != nil {
+ panic(fmt.Errorf("s.Serve(store) failed:%v", err))
+ }
gs.storeEndpoint = "/" + gs.myIPAddr + storeServicePort
}
func initSyncService(peerEndpoint string) {
peerSyncAddr := strings.Split(peerEndpoint, ":")[0]
srv := vsync.NewServerSync(vsync.NewSyncd(peerSyncAddr+syncServicePort, peerSyncAddr /* peer deviceID */, gs.myIPAddr /* my deviceID */, storePath, gs.storeEndpoint, 0))
- if err := gs.ipc.Register("sync", ipc.SoloDispatcher(srv, nil)); err != nil {
- panic(fmt.Errorf("syncd:: error registering service: err %v", err))
- }
+ gs.disp.syncAuth = nil
+ gs.disp.syncServer = ipc.ReflectInvoker(srv)
if _, err := gs.ipc.Listen("tcp", gs.myIPAddr+syncServicePort); err != nil {
panic(fmt.Errorf("syncd:: error listening to service: err %v", err))
}
+ if err := gs.ipc.Serve("", &gs.disp); err != nil {
+ panic(fmt.Errorf("syncd:: error serving service: err %v", err))
+ }
}
func init() {
diff --git a/examples/boxes/signallingserver/main.go b/examples/boxes/signallingserver/main.go
index 04536d4..6a5074b 100644
--- a/examples/boxes/signallingserver/main.go
+++ b/examples/boxes/signallingserver/main.go
@@ -4,12 +4,14 @@
import (
"log"
+ "strings"
"veyron/examples/boxes"
"veyron/lib/signals"
"veyron2/ipc"
"veyron2/rt"
+ "veyron2/security"
)
const (
@@ -30,6 +32,15 @@
return string(*b), nil
}
+type dispatcher struct {
+ invoker ipc.Invoker
+}
+
+func (d *dispatcher) Lookup(suffix string) (ipc.Invoker, security.Authorizer, error) {
+ suffix = strings.TrimPrefix(suffix, signallingServiceName)
+ return d.invoker, nil, nil
+}
+
func main() {
r := rt.Init()
@@ -49,7 +60,7 @@
log.Fatal("failed Listen: ", err)
}
- if err := s.Serve("/"+signallingServiceName, ipc.SoloDispatcher(srv, nil)); err != nil {
+ if err := s.Serve("", &dispatcher{ipc.ReflectInvoker(srv)}); err != nil {
log.Fatal("failed Serve:", err)
}
diff --git a/examples/stfortune/stfortune/main.go b/examples/stfortune/stfortune/main.go
index a6231e1..4086ba2 100644
--- a/examples/stfortune/stfortune/main.go
+++ b/examples/stfortune/stfortune/main.go
@@ -17,9 +17,12 @@
"veyron2/context"
"veyron2/naming"
"veyron2/rt"
+ istore "veyron2/services/store"
+ iwatch "veyron2/services/watch"
"veyron2/storage"
"veyron2/storage/vstore"
"veyron2/storage/vstore/primitives"
+ "veyron2/vom"
)
func fortunePath(name string) string {
@@ -42,21 +45,24 @@
func waitForStore(store storage.Store) {
ctx := rt.R().NewContext()
+ // Register *store.Entry for WatchGlob.
+ // TODO(tilaks): store.Entry is declared in vdl, vom should register the
+ // pointer automatically.
+ vom.Register(&istore.Entry{})
+
fmt.Printf("Waiting for Store to be initialized with fortune schema...\n")
// List of paths to check in store.
paths := []string{appPath, fortunePath(""), userPath("")}
- for _, p := range paths {
- for {
- exists, err := store.Bind(p).Exists(ctx, nil)
- if err != nil {
- log.Fatalf("exists %s failed: %v", p, err)
- }
- if exists {
- break
- }
- // Retry until ready.
- time.Sleep(5 * time.Second)
+ for _, path := range paths {
+ req := iwatch.GlobRequest{Pattern: ""}
+ stream, err := store.Bind(path).WatchGlob(ctx, req)
+ if err != nil {
+ log.Fatalf("WatchGlob %s failed: %v", path, err)
}
+ if _, err := stream.Recv(); err != nil {
+ log.Fatalf("Recv failed: %v", err)
+ }
+ stream.Cancel()
}
fmt.Printf("Store is ready\n")
diff --git a/runtimes/google/ipc/stream/vif/vif.go b/runtimes/google/ipc/stream/vif/vif.go
index 56586d6..15ea933 100644
--- a/runtimes/google/ipc/stream/vif/vif.go
+++ b/runtimes/google/ipc/stream/vif/vif.go
@@ -21,6 +21,7 @@
"veyron/runtimes/google/lib/bqueue/drrqueue"
"veyron/runtimes/google/lib/iobuf"
"veyron/runtimes/google/lib/pcqueue"
+ vsync "veyron/runtimes/google/lib/sync"
"veyron/runtimes/google/lib/upcqueue"
"veyron2/ipc/stream"
@@ -39,7 +40,7 @@
localEP naming.Endpoint
vcMap *vcMap
- wpending, rpending *waitGroup
+ wpending, rpending vsync.WaitGroup
muListen sync.Mutex
acceptor *upcqueue.T // GUARDED_BY(muListen)
@@ -160,8 +161,6 @@
conn: conn,
pool: iobuf.NewPool(0),
vcMap: newVCMap(),
- wpending: newWaitGroup(),
- rpending: newWaitGroup(),
acceptor: acceptor,
listenerOpts: listenerOpts,
localEP: ep,
@@ -731,50 +730,3 @@
b.Release()
}
}
-
-// waitGroup implements a sync.WaitGroup like structure that does not require
-// all calls to Add to be made before Wait, instead calls to Add after Wait
-// will fail.
-type waitGroup struct {
- n int
- wait bool
- mu sync.Mutex
- cond *sync.Cond
-}
-
-func newWaitGroup() *waitGroup {
- w := &waitGroup{}
- w.cond = sync.NewCond(&w.mu)
- return w
-}
-
-func (w *waitGroup) TryAdd() bool {
- w.mu.Lock()
- defer w.mu.Unlock()
- if !w.wait {
- w.n++
- return true
- }
- return false
-}
-
-func (w *waitGroup) Done() {
- w.mu.Lock()
- defer w.mu.Unlock()
- w.n--
- if w.n < 0 {
- panic(fmt.Sprintf("more calls to Done than Add"))
- }
- if w.n == 0 {
- w.cond.Broadcast()
- }
-}
-
-func (w *waitGroup) Wait() {
- w.mu.Lock()
- w.wait = true
- for w.n > 0 {
- w.cond.Wait()
- }
- w.mu.Unlock()
-}
diff --git a/runtimes/google/lib/sync/doc.go b/runtimes/google/lib/sync/doc.go
new file mode 100644
index 0000000..3e184b9
--- /dev/null
+++ b/runtimes/google/lib/sync/doc.go
@@ -0,0 +1,2 @@
+// Package sync provides synchronization primitives.
+package sync
diff --git a/runtimes/google/lib/sync/semaphore.go b/runtimes/google/lib/sync/semaphore.go
index 1a4cc18..b6ea778 100644
--- a/runtimes/google/lib/sync/semaphore.go
+++ b/runtimes/google/lib/sync/semaphore.go
@@ -1,4 +1,3 @@
-// Package sync provides synchronization primitives.
package sync
import (
diff --git a/runtimes/google/lib/sync/wait_group.go b/runtimes/google/lib/sync/wait_group.go
new file mode 100644
index 0000000..3ee2ec1
--- /dev/null
+++ b/runtimes/google/lib/sync/wait_group.go
@@ -0,0 +1,57 @@
+package sync
+
+import "sync"
+
+// WaitGroup implements a sync.WaitGroup-like structure that does not require
+// all calls to Add to be made before Wait, instead calls to Add after Wait
+// will fail.
+//
+// As a result, WaitGroup cannot be "re-used" in the way that sync.WaitGroup
+// can. In the following example using sync.WaitGroup, Add, Done and Wait behave
+// in the same way in rounds 1 and 2.
+//
+// var wg sync.WaitGroup
+//
+// Round #1.
+// wg.Add(1)
+// go wg.Done()
+// wg.Wait()
+//
+// Round #2.
+// wg.Add(1)
+// go wg.Done()
+// wg.Wait()
+//
+// However, an equivalent program using WaitGroup would receive an error on the
+// second call to TryAdd.
+type WaitGroup struct {
+ mu sync.Mutex
+ waiting bool
+ pending sync.WaitGroup
+}
+
+// TryAdd attempts to increment the counter. If Wait has already been called,
+// TryAdd fails to increment the counter and returns false.
+// If the counter becomes zero, all goroutines blocked on Wait are released.
+func (w *WaitGroup) TryAdd() (added bool) {
+ w.mu.Lock()
+ defer w.mu.Unlock()
+ if w.waiting {
+ return false
+ }
+ w.pending.Add(1)
+ return true
+}
+
+// Done decrements the counter. If the counter goes negative, Done panics.
+func (w *WaitGroup) Done() {
+ w.pending.Done()
+}
+
+// Wait blocks until the counter is zero.
+func (w *WaitGroup) Wait() {
+ w.mu.Lock()
+ w.waiting = true
+ w.mu.Unlock()
+ w.pending.Wait()
+}
diff --git a/runtimes/google/lib/sync/wait_group_test.go b/runtimes/google/lib/sync/wait_group_test.go
new file mode 100644
index 0000000..7a6bc92
--- /dev/null
+++ b/runtimes/google/lib/sync/wait_group_test.go
@@ -0,0 +1,118 @@
+package sync
+
+import (
+ "testing"
+ "veyron/lib/testutil"
+)
+
+// TestRandom tests Wait after a random sequence of TryAdd's and Done's that
+// leaves the counter at 0.
+func TestRandom(t *testing.T) {
+ var w WaitGroup
+ N := 100
+
+ count := 0
+ for n := 0; n < N; n++ {
+ if count == 0 || testutil.Rand.Intn(2) == 0 {
+ if !w.TryAdd() {
+ t.Fatal("TryAdd failed")
+ }
+ count++
+ continue
+ }
+ w.Done()
+ count--
+ }
+ for d := 0; d < count; d++ {
+ w.Done()
+ }
+
+ w.Wait()
+}
+
+func TestConcurrentWait(t *testing.T) {
+ for r := 0; r < 100; r++ {
+ var w WaitGroup
+
+ done := make(chan struct{}, 1)
+
+ if !w.TryAdd() {
+ t.Fatal("TryAdd failed")
+ }
+
+ go func() {
+ w.Wait()
+ // w.Wait() should not return before w.Done() sets the counter
+ // to 0.
+ // This test is not deterministic as we cannot infer the order
+ // in which Wait() and the last Done() return. Hopefully, bugs
+ // will revealed by repeating the test.
+ select {
+ case <-done:
+ default:
+ t.Fatal("Wait returned before Done.")
+ }
+ }()
+
+ for w.TryAdd() {
+ w.Done()
+ }
+ close(done)
+ w.Done()
+ }
+}
+
+func TestTryAddFailsAfterWait(t *testing.T) {
+ var w WaitGroup
+
+ if !w.TryAdd() {
+ t.Fatal("TryAdd failed")
+ }
+
+ go w.Wait()
+
+ // At some point, another goroutine will be in w.Wait() and w.TryAdd()
+ // should fail. If this doesn't happen, the test will never terminate.
+ for w.TryAdd() {
+ w.Done()
+ }
+ w.Done()
+}
+
+func TestIdempotentWait(t *testing.T) {
+ var w WaitGroup
+
+ done := make(chan struct{}, 1)
+
+ if !w.TryAdd() {
+ t.Fatal("TryAdd failed")
+ }
+
+ // w.Wait() should be idempotent.
+ for i := 0; i < 2; i++ {
+ go func() {
+ w.Wait()
+ select {
+ case <-done:
+ default:
+ t.Fatal("Wait returned before Done.")
+ }
+ }()
+ }
+
+ for w.TryAdd() {
+ w.Done()
+ }
+ close(done)
+ w.Done()
+}
+
+func TestDoneFailsBeforeAdd(t *testing.T) {
+ var w WaitGroup
+ defer func() {
+ if r := recover(); r == nil {
+ t.Fatal("Done succeeded before Add.")
+ }
+ }()
+ w.Done()
+}
diff --git a/runtimes/google/vsync/vsync.vdl b/runtimes/google/vsync/vsync.vdl
index aa06ec9..f6d8b9b 100644
--- a/runtimes/google/vsync/vsync.vdl
+++ b/runtimes/google/vsync/vsync.vdl
@@ -28,7 +28,7 @@
// It contains log related metadata: DevID is the id of the
// device that created the log record, GNum is the ID of the
// generation that the log record is part of, LSN is the log
-// sequence number of the log record in the generation GNum,
+// sequence number of the log record in the generation GNum,
// and RecType is the type of log record.
//
// It also contains information relevant to the updates to an object
@@ -59,10 +59,10 @@
// Delete indicates whether the mutation resulted in the object being
// deleted from the store.
Delete bool
- // Continue tracks the transaction boundaries in a range of mutations.
+ // Continued tracks the transaction boundaries in a range of mutations.
// It is set to true in all transaction mutations except the last one
// in which it is set to false to mark the end of the transaction.
- Continue bool
+ Continued bool
}
// Sync allows a device to GetDeltas from another device.
diff --git a/runtimes/google/vsync/vsync.vdl.go b/runtimes/google/vsync/vsync.vdl.go
index e2120db..fb9834a 100644
--- a/runtimes/google/vsync/vsync.vdl.go
+++ b/runtimes/google/vsync/vsync.vdl.go
@@ -67,10 +67,10 @@
// Delete indicates whether the mutation resulted in the object being
// deleted from the store.
Delete bool
- // Continue tracks the transaction boundaries in a range of mutations.
+ // Continued tracks the transaction boundaries in a range of mutations.
// It is set to true in all transaction mutations except the last one
// in which it is set to false to mark the end of the transaction.
- Continue bool
+ Continued bool
}
const (
@@ -305,7 +305,7 @@
_gen_wiretype.FieldType{Type: 0x50, Name: "Mutation"},
_gen_wiretype.FieldType{Type: 0x25, Name: "SyncTime"},
_gen_wiretype.FieldType{Type: 0x2, Name: "Delete"},
- _gen_wiretype.FieldType{Type: 0x2, Name: "Continue"},
+ _gen_wiretype.FieldType{Type: 0x2, Name: "Continued"},
},
"veyron/runtimes/google/vsync.LogValue", []string(nil)},
_gen_wiretype.StructType{
diff --git a/runtimes/google/vsync/watcher.go b/runtimes/google/vsync/watcher.go
index d101d7b..f911231 100644
--- a/runtimes/google/vsync/watcher.go
+++ b/runtimes/google/vsync/watcher.go
@@ -166,7 +166,7 @@
return fmt.Errorf("invalid change value, not a mutation: %#v", ch)
}
- val := &LogValue{Mutation: *mu, SyncTime: syncTime, Delete: ch.State == watch.DoesNotExist, Continue: ch.Continued}
+ val := &LogValue{Mutation: *mu, SyncTime: syncTime, Delete: ch.State == watch.DoesNotExist, Continued: ch.Continued}
var parents []storage.Version
if mu.PriorVersion != storage.NoVersion {
parents = []storage.Version{mu.PriorVersion}
diff --git a/services/store/memstore/query/eval.go b/services/store/memstore/query/eval.go
index 3b65a30..d8a78d8 100644
--- a/services/store/memstore/query/eval.go
+++ b/services/store/memstore/query/eval.go
@@ -10,6 +10,7 @@
"sync"
"veyron2/vlog"
+ vsync "veyron/runtimes/google/lib/sync"
"veyron/services/store/memstore/state"
"veyron/services/store/service"
@@ -46,7 +47,7 @@
// to this stack. The top of the stack is the end of the slice.
results []nestedChannel
// cleanup is used for testing to ensure that no goroutines are leaked.
- cleanup sync.WaitGroup
+ cleanup vsync.WaitGroup
// maxNesting is the largest value used for nestedChannel.nesting. It
// is the maximum nesting over the duration of the query while len(results)
// is just the instantaneous nesting.
@@ -207,7 +208,10 @@
results: []nestedChannel{nestedChannel{0, out}},
abort: make(chan struct{}),
}
- it.cleanup.Add(1)
+ if !it.cleanup.TryAdd() {
+ // The query has been aborted by a call to Cancel.
+ return it
+ }
go evaluator.eval(&context{
sn: sn,
suffix: name.String(),
@@ -218,6 +222,7 @@
abort: it.abort,
cleanup: &it.cleanup,
})
+
return it
}
@@ -246,7 +251,7 @@
abort chan struct{}
// cleanup is used for testing to ensure that no goroutines are leaked.
// evaluator.eval implementations should call Done when finished processing.
- cleanup *sync.WaitGroup
+ cleanup *vsync.WaitGroup
}
// emit sends result on c.out. It is careful to watch for aborts. result can be
@@ -392,7 +397,11 @@
abort: c.abort,
cleanup: c.cleanup,
}
- c.cleanup.Add(1)
+ if !c.cleanup.TryAdd() {
+ // The query has been aborted by a call to Cancel.
+ close(srcOut)
+ return srcOut
+ }
go src.eval(&srcContext)
return srcOut
}
@@ -543,7 +552,10 @@
abort: c.abort,
cleanup: c.cleanup,
}
- c.cleanup.Add(1)
+ if !c.cleanup.TryAdd() {
+ // The query has been aborted by a call to Cancel.
+ return false
+ }
go a.evaluator.eval(ctxt)
// If the subpipeline would produce a single result, use that single result
diff --git a/services/store/memstore/watch/watcher.go b/services/store/memstore/watch/watcher.go
index 5956110..4cf8562 100644
--- a/services/store/memstore/watch/watcher.go
+++ b/services/store/memstore/watch/watcher.go
@@ -5,9 +5,9 @@
"encoding/binary"
"errors"
"io"
- "sync"
"time"
+ "veyron/runtimes/google/lib/sync"
"veyron/services/store/memstore"
"veyron/services/store/raw"
"veyron/services/store/service"
@@ -103,7 +103,9 @@
done := make(chan error, 1)
- w.pending.Add(1)
+ if !w.pending.TryAdd() {
+ return ErrWatchClosed
+ }
// This goroutine does not leak because processRequest is always terminated.
go func() {
defer w.pending.Done()
diff --git a/tools/vrpc/impl/impl_test.go b/tools/vrpc/impl/impl_test.go
index 262f3e8..ee67bf0 100644
--- a/tools/vrpc/impl/impl_test.go
+++ b/tools/vrpc/impl/impl_test.go
@@ -21,48 +21,48 @@
// TypeTester interface implementation
-func (*server) Bool(call ipc.ServerContext, i1 bool) (bool, error) {
- vlog.VI(2).Info("Bool(%v) was called.", i1)
+func (*server) EchoBool(call ipc.ServerContext, i1 bool) (bool, error) {
+ vlog.VI(2).Info("EchoBool(%v) was called.", i1)
return i1, nil
}
-func (*server) Float32(call ipc.ServerContext, i1 float32) (float32, error) {
- vlog.VI(2).Info("Float32(%u) was called.", i1)
+func (*server) EchoFloat32(call ipc.ServerContext, i1 float32) (float32, error) {
+ vlog.VI(2).Info("EchoFloat32(%u) was called.", i1)
return i1, nil
}
-func (*server) Float64(call ipc.ServerContext, i1 float64) (float64, error) {
- vlog.VI(2).Info("Float64(%u) was called.", i1)
+func (*server) EchoFloat64(call ipc.ServerContext, i1 float64) (float64, error) {
+ vlog.VI(2).Info("EchoFloat64(%u) was called.", i1)
return i1, nil
}
-func (*server) Int32(call ipc.ServerContext, i1 int32) (int32, error) {
- vlog.VI(2).Info("Int32(%v) was called.", i1)
+func (*server) EchoInt32(call ipc.ServerContext, i1 int32) (int32, error) {
+ vlog.VI(2).Info("EchoInt32(%v) was called.", i1)
return i1, nil
}
-func (*server) Int64(call ipc.ServerContext, i1 int64) (int64, error) {
- vlog.VI(2).Info("Int64(%v) was called.", i1)
+func (*server) EchoInt64(call ipc.ServerContext, i1 int64) (int64, error) {
+ vlog.VI(2).Info("EchoInt64(%v) was called.", i1)
return i1, nil
}
-func (*server) String(call ipc.ServerContext, i1 string) (string, error) {
- vlog.VI(2).Info("String(%v) was called.", i1)
+func (*server) EchoString(call ipc.ServerContext, i1 string) (string, error) {
+ vlog.VI(2).Info("EchoString(%v) was called.", i1)
return i1, nil
}
-func (*server) Byte(call ipc.ServerContext, i1 byte) (byte, error) {
- vlog.VI(2).Info("Byte(%v) was called.", i1)
+func (*server) EchoByte(call ipc.ServerContext, i1 byte) (byte, error) {
+ vlog.VI(2).Info("EchoByte(%v) was called.", i1)
return i1, nil
}
-func (*server) UInt32(call ipc.ServerContext, i1 uint32) (uint32, error) {
- vlog.VI(2).Info("UInt32(%u) was called.", i1)
+func (*server) EchoUInt32(call ipc.ServerContext, i1 uint32) (uint32, error) {
+ vlog.VI(2).Info("EchoUInt32(%u) was called.", i1)
return i1, nil
}
-func (*server) UInt64(call ipc.ServerContext, i1 uint64) (uint64, error) {
- vlog.VI(2).Info("UInt64(%u) was called.", i1)
+func (*server) EchoUInt64(call ipc.ServerContext, i1 uint64) (uint64, error) {
+ vlog.VI(2).Info("EchoUInt64(%u) was called.", i1)
return i1, nil
}
@@ -191,15 +191,15 @@
}
expectedSignature := []string{
- "func Bool(I1 bool) (O1 bool, E error)",
- "func Float32(I1 float32) (O1 float32, E error)",
- "func Float64(I1 float64) (O1 float64, E error)",
- "func Int32(I1 int32) (O1 int32, E error)",
- "func Int64(I1 int64) (O1 int64, E error)",
- "func String(I1 string) (O1 string, E error)",
- "func Byte(I1 byte) (O1 byte, E error)",
- "func UInt32(I1 uint32) (O1 uint32, E error)",
- "func UInt64(I1 uint64) (O1 uint64, E error)",
+ "func EchoBool(I1 bool) (O1 bool, E error)",
+ "func EchoFloat32(I1 float32) (O1 float32, E error)",
+ "func EchoFloat64(I1 float64) (O1 float64, E error)",
+ "func EchoInt32(I1 int32) (O1 int32, E error)",
+ "func EchoInt64(I1 int64) (O1 int64, E error)",
+ "func EchoString(I1 string) (O1 string, E error)",
+ "func EchoByte(I1 byte) (O1 byte, E error)",
+ "func EchoUInt32(I1 uint32) (O1 uint32, E error)",
+ "func EchoUInt64(I1 uint64) (O1 uint64, E error)",
"func InputArray(I1 [2]byte) (E error)",
"func InputMap(I1 map[byte]byte) (E error)",
"func InputSlice(I1 []byte) (E error)",
@@ -236,15 +236,15 @@
// Test the 'invoke' command.
tests := [][]string{
- []string{"Bool", "Bool(true) = [true, <nil>]", "[\"bool\",true]"},
- []string{"Float32", "Float32(3.2) = [3.2, <nil>]", "[\"float32\",3.2]"},
- []string{"Float64", "Float64(6.4) = [6.4, <nil>]", "[\"float64\",6.4]"},
- []string{"Int32", "Int32(-32) = [-32, <nil>]", "[\"int32\",-32]"},
- []string{"Int64", "Int64(-64) = [-64, <nil>]", "[\"int64\",-64]"},
- []string{"String", "String(Hello World!) = [Hello World!, <nil>]", "[\"string\",\"Hello World!\"]"},
- []string{"Byte", "Byte(8) = [8, <nil>]", "[\"byte\",8]"},
- []string{"UInt32", "UInt32(32) = [32, <nil>]", "[\"uint32\",32]"},
- []string{"UInt64", "UInt64(64) = [64, <nil>]", "[\"uint64\",64]"},
+ []string{"EchoBool", "EchoBool(true) = [true, <nil>]", "[\"bool\",true]"},
+ []string{"EchoFloat32", "EchoFloat32(3.2) = [3.2, <nil>]", "[\"float32\",3.2]"},
+ []string{"EchoFloat64", "EchoFloat64(6.4) = [6.4, <nil>]", "[\"float64\",6.4]"},
+ []string{"EchoInt32", "EchoInt32(-32) = [-32, <nil>]", "[\"int32\",-32]"},
+ []string{"EchoInt64", "EchoInt64(-64) = [-64, <nil>]", "[\"int64\",-64]"},
+ []string{"EchoString", "EchoString(Hello World!) = [Hello World!, <nil>]", "[\"string\",\"Hello World!\"]"},
+ []string{"EchoByte", "EchoByte(8) = [8, <nil>]", "[\"byte\",8]"},
+ []string{"EchoUInt32", "EchoUInt32(32) = [32, <nil>]", "[\"uint32\",32]"},
+ []string{"EchoUInt64", "EchoUInt64(64) = [64, <nil>]", "[\"uint64\",64]"},
// TODO(jsimsa): The InputArray currently triggers an error in the
// vom decoder. Benj is looking into this.
//
@@ -274,7 +274,7 @@
}
testErrors := [][]string{
- []string{"Bool", "usage error"},
+ []string{"EchoBool", "usage error"},
[]string{"DoesNotExit", "invoke: method DoesNotExit not found"},
}
for _, test := range testErrors {
diff --git a/tools/vrpc/test_base/test_base.vdl b/tools/vrpc/test_base/test_base.vdl
index 05b8de4..ba6496c 100644
--- a/tools/vrpc/test_base/test_base.vdl
+++ b/tools/vrpc/test_base/test_base.vdl
@@ -6,15 +6,15 @@
type TypeTester interface {
// Methods to test support for generic types.
- Bool(I1 bool) (O1 bool, E error)
- Float32(I1 float32) (O1 float32, E error)
- Float64(I1 float64) (O1 float64, E error)
- Int32(I1 int32) (O1 int32, E error)
- Int64(I1 int64) (O1 int64, E error)
- String(I1 string) (O1 string, E error)
- Byte(I1 byte) (O1 byte, E error)
- UInt32(I1 uint32) (O1 uint32, E error)
- UInt64(I1 uint64) (O1 uint64, E error)
+ EchoBool(I1 bool) (O1 bool, E error)
+ EchoFloat32(I1 float32) (O1 float32, E error)
+ EchoFloat64(I1 float64) (O1 float64, E error)
+ EchoInt32(I1 int32) (O1 int32, E error)
+ EchoInt64(I1 int64) (O1 int64, E error)
+ EchoString(I1 string) (O1 string, E error)
+ EchoByte(I1 byte) (O1 byte, E error)
+ EchoUInt32(I1 uint32) (O1 uint32, E error)
+ EchoUInt64(I1 uint64) (O1 uint64, E error)
// Methods to test support for composite types.
InputArray(I1 [2]byte) (E error)
diff --git a/tools/vrpc/test_base/test_base.vdl.go b/tools/vrpc/test_base/test_base.vdl.go
index eabe26a..958f64e 100644
--- a/tools/vrpc/test_base/test_base.vdl.go
+++ b/tools/vrpc/test_base/test_base.vdl.go
@@ -24,15 +24,15 @@
// to enable embedding without method collisions. Not to be used directly by clients.
type TypeTester_ExcludingUniversal interface {
// Methods to test support for generic types.
- Bool(ctx _gen_context.T, I1 bool, opts ..._gen_ipc.CallOpt) (reply bool, err error)
- Float32(ctx _gen_context.T, I1 float32, opts ..._gen_ipc.CallOpt) (reply float32, err error)
- Float64(ctx _gen_context.T, I1 float64, opts ..._gen_ipc.CallOpt) (reply float64, err error)
- Int32(ctx _gen_context.T, I1 int32, opts ..._gen_ipc.CallOpt) (reply int32, err error)
- Int64(ctx _gen_context.T, I1 int64, opts ..._gen_ipc.CallOpt) (reply int64, err error)
- String(ctx _gen_context.T, I1 string, opts ..._gen_ipc.CallOpt) (reply string, err error)
- Byte(ctx _gen_context.T, I1 byte, opts ..._gen_ipc.CallOpt) (reply byte, err error)
- UInt32(ctx _gen_context.T, I1 uint32, opts ..._gen_ipc.CallOpt) (reply uint32, err error)
- UInt64(ctx _gen_context.T, I1 uint64, opts ..._gen_ipc.CallOpt) (reply uint64, err error)
+ EchoBool(ctx _gen_context.T, I1 bool, opts ..._gen_ipc.CallOpt) (reply bool, err error)
+ EchoFloat32(ctx _gen_context.T, I1 float32, opts ..._gen_ipc.CallOpt) (reply float32, err error)
+ EchoFloat64(ctx _gen_context.T, I1 float64, opts ..._gen_ipc.CallOpt) (reply float64, err error)
+ EchoInt32(ctx _gen_context.T, I1 int32, opts ..._gen_ipc.CallOpt) (reply int32, err error)
+ EchoInt64(ctx _gen_context.T, I1 int64, opts ..._gen_ipc.CallOpt) (reply int64, err error)
+ EchoString(ctx _gen_context.T, I1 string, opts ..._gen_ipc.CallOpt) (reply string, err error)
+ EchoByte(ctx _gen_context.T, I1 byte, opts ..._gen_ipc.CallOpt) (reply byte, err error)
+ EchoUInt32(ctx _gen_context.T, I1 uint32, opts ..._gen_ipc.CallOpt) (reply uint32, err error)
+ EchoUInt64(ctx _gen_context.T, I1 uint64, opts ..._gen_ipc.CallOpt) (reply uint64, err error)
// Methods to test support for composite types.
InputArray(ctx _gen_context.T, I1 [2]byte, opts ..._gen_ipc.CallOpt) (err error)
InputMap(ctx _gen_context.T, I1 map[byte]byte, opts ..._gen_ipc.CallOpt) (err error)
@@ -57,15 +57,15 @@
type TypeTesterService interface {
// Methods to test support for generic types.
- Bool(context _gen_ipc.ServerContext, I1 bool) (reply bool, err error)
- Float32(context _gen_ipc.ServerContext, I1 float32) (reply float32, err error)
- Float64(context _gen_ipc.ServerContext, I1 float64) (reply float64, err error)
- Int32(context _gen_ipc.ServerContext, I1 int32) (reply int32, err error)
- Int64(context _gen_ipc.ServerContext, I1 int64) (reply int64, err error)
- String(context _gen_ipc.ServerContext, I1 string) (reply string, err error)
- Byte(context _gen_ipc.ServerContext, I1 byte) (reply byte, err error)
- UInt32(context _gen_ipc.ServerContext, I1 uint32) (reply uint32, err error)
- UInt64(context _gen_ipc.ServerContext, I1 uint64) (reply uint64, err error)
+ EchoBool(context _gen_ipc.ServerContext, I1 bool) (reply bool, err error)
+ EchoFloat32(context _gen_ipc.ServerContext, I1 float32) (reply float32, err error)
+ EchoFloat64(context _gen_ipc.ServerContext, I1 float64) (reply float64, err error)
+ EchoInt32(context _gen_ipc.ServerContext, I1 int32) (reply int32, err error)
+ EchoInt64(context _gen_ipc.ServerContext, I1 int64) (reply int64, err error)
+ EchoString(context _gen_ipc.ServerContext, I1 string) (reply string, err error)
+ EchoByte(context _gen_ipc.ServerContext, I1 byte) (reply byte, err error)
+ EchoUInt32(context _gen_ipc.ServerContext, I1 uint32) (reply uint32, err error)
+ EchoUInt64(context _gen_ipc.ServerContext, I1 uint64) (reply uint64, err error)
// Methods to test support for composite types.
InputArray(context _gen_ipc.ServerContext, I1 [2]byte) (err error)
InputMap(context _gen_ipc.ServerContext, I1 map[byte]byte) (err error)
@@ -179,9 +179,9 @@
name string
}
-func (__gen_c *clientStubTypeTester) Bool(ctx _gen_context.T, I1 bool, opts ..._gen_ipc.CallOpt) (reply bool, err error) {
+func (__gen_c *clientStubTypeTester) EchoBool(ctx _gen_context.T, I1 bool, opts ..._gen_ipc.CallOpt) (reply bool, err error) {
var call _gen_ipc.Call
- if call, err = __gen_c.client.StartCall(ctx, __gen_c.name, "Bool", []interface{}{I1}, opts...); err != nil {
+ if call, err = __gen_c.client.StartCall(ctx, __gen_c.name, "EchoBool", []interface{}{I1}, opts...); err != nil {
return
}
if ierr := call.Finish(&reply, &err); ierr != nil {
@@ -190,9 +190,9 @@
return
}
-func (__gen_c *clientStubTypeTester) Float32(ctx _gen_context.T, I1 float32, opts ..._gen_ipc.CallOpt) (reply float32, err error) {
+func (__gen_c *clientStubTypeTester) EchoFloat32(ctx _gen_context.T, I1 float32, opts ..._gen_ipc.CallOpt) (reply float32, err error) {
var call _gen_ipc.Call
- if call, err = __gen_c.client.StartCall(ctx, __gen_c.name, "Float32", []interface{}{I1}, opts...); err != nil {
+ if call, err = __gen_c.client.StartCall(ctx, __gen_c.name, "EchoFloat32", []interface{}{I1}, opts...); err != nil {
return
}
if ierr := call.Finish(&reply, &err); ierr != nil {
@@ -201,9 +201,9 @@
return
}
-func (__gen_c *clientStubTypeTester) Float64(ctx _gen_context.T, I1 float64, opts ..._gen_ipc.CallOpt) (reply float64, err error) {
+func (__gen_c *clientStubTypeTester) EchoFloat64(ctx _gen_context.T, I1 float64, opts ..._gen_ipc.CallOpt) (reply float64, err error) {
var call _gen_ipc.Call
- if call, err = __gen_c.client.StartCall(ctx, __gen_c.name, "Float64", []interface{}{I1}, opts...); err != nil {
+ if call, err = __gen_c.client.StartCall(ctx, __gen_c.name, "EchoFloat64", []interface{}{I1}, opts...); err != nil {
return
}
if ierr := call.Finish(&reply, &err); ierr != nil {
@@ -212,9 +212,9 @@
return
}
-func (__gen_c *clientStubTypeTester) Int32(ctx _gen_context.T, I1 int32, opts ..._gen_ipc.CallOpt) (reply int32, err error) {
+func (__gen_c *clientStubTypeTester) EchoInt32(ctx _gen_context.T, I1 int32, opts ..._gen_ipc.CallOpt) (reply int32, err error) {
var call _gen_ipc.Call
- if call, err = __gen_c.client.StartCall(ctx, __gen_c.name, "Int32", []interface{}{I1}, opts...); err != nil {
+ if call, err = __gen_c.client.StartCall(ctx, __gen_c.name, "EchoInt32", []interface{}{I1}, opts...); err != nil {
return
}
if ierr := call.Finish(&reply, &err); ierr != nil {
@@ -223,9 +223,9 @@
return
}
-func (__gen_c *clientStubTypeTester) Int64(ctx _gen_context.T, I1 int64, opts ..._gen_ipc.CallOpt) (reply int64, err error) {
+func (__gen_c *clientStubTypeTester) EchoInt64(ctx _gen_context.T, I1 int64, opts ..._gen_ipc.CallOpt) (reply int64, err error) {
var call _gen_ipc.Call
- if call, err = __gen_c.client.StartCall(ctx, __gen_c.name, "Int64", []interface{}{I1}, opts...); err != nil {
+ if call, err = __gen_c.client.StartCall(ctx, __gen_c.name, "EchoInt64", []interface{}{I1}, opts...); err != nil {
return
}
if ierr := call.Finish(&reply, &err); ierr != nil {
@@ -234,9 +234,9 @@
return
}
-func (__gen_c *clientStubTypeTester) String(ctx _gen_context.T, I1 string, opts ..._gen_ipc.CallOpt) (reply string, err error) {
+func (__gen_c *clientStubTypeTester) EchoString(ctx _gen_context.T, I1 string, opts ..._gen_ipc.CallOpt) (reply string, err error) {
var call _gen_ipc.Call
- if call, err = __gen_c.client.StartCall(ctx, __gen_c.name, "String", []interface{}{I1}, opts...); err != nil {
+ if call, err = __gen_c.client.StartCall(ctx, __gen_c.name, "EchoString", []interface{}{I1}, opts...); err != nil {
return
}
if ierr := call.Finish(&reply, &err); ierr != nil {
@@ -245,9 +245,9 @@
return
}
-func (__gen_c *clientStubTypeTester) Byte(ctx _gen_context.T, I1 byte, opts ..._gen_ipc.CallOpt) (reply byte, err error) {
+func (__gen_c *clientStubTypeTester) EchoByte(ctx _gen_context.T, I1 byte, opts ..._gen_ipc.CallOpt) (reply byte, err error) {
var call _gen_ipc.Call
- if call, err = __gen_c.client.StartCall(ctx, __gen_c.name, "Byte", []interface{}{I1}, opts...); err != nil {
+ if call, err = __gen_c.client.StartCall(ctx, __gen_c.name, "EchoByte", []interface{}{I1}, opts...); err != nil {
return
}
if ierr := call.Finish(&reply, &err); ierr != nil {
@@ -256,9 +256,9 @@
return
}
-func (__gen_c *clientStubTypeTester) UInt32(ctx _gen_context.T, I1 uint32, opts ..._gen_ipc.CallOpt) (reply uint32, err error) {
+func (__gen_c *clientStubTypeTester) EchoUInt32(ctx _gen_context.T, I1 uint32, opts ..._gen_ipc.CallOpt) (reply uint32, err error) {
var call _gen_ipc.Call
- if call, err = __gen_c.client.StartCall(ctx, __gen_c.name, "UInt32", []interface{}{I1}, opts...); err != nil {
+ if call, err = __gen_c.client.StartCall(ctx, __gen_c.name, "EchoUInt32", []interface{}{I1}, opts...); err != nil {
return
}
if ierr := call.Finish(&reply, &err); ierr != nil {
@@ -267,9 +267,9 @@
return
}
-func (__gen_c *clientStubTypeTester) UInt64(ctx _gen_context.T, I1 uint64, opts ..._gen_ipc.CallOpt) (reply uint64, err error) {
+func (__gen_c *clientStubTypeTester) EchoUInt64(ctx _gen_context.T, I1 uint64, opts ..._gen_ipc.CallOpt) (reply uint64, err error) {
var call _gen_ipc.Call
- if call, err = __gen_c.client.StartCall(ctx, __gen_c.name, "UInt64", []interface{}{I1}, opts...); err != nil {
+ if call, err = __gen_c.client.StartCall(ctx, __gen_c.name, "EchoUInt64", []interface{}{I1}, opts...); err != nil {
return
}
if ierr := call.Finish(&reply, &err); ierr != nil {
@@ -442,23 +442,23 @@
// Note: This exhibits some weird behavior like returning a nil error if the method isn't found.
// This will change when it is replaced with Signature().
switch method {
- case "Bool":
+ case "EchoBool":
return []interface{}{}, nil
- case "Float32":
+ case "EchoFloat32":
return []interface{}{}, nil
- case "Float64":
+ case "EchoFloat64":
return []interface{}{}, nil
- case "Int32":
+ case "EchoInt32":
return []interface{}{}, nil
- case "Int64":
+ case "EchoInt64":
return []interface{}{}, nil
- case "String":
+ case "EchoString":
return []interface{}{}, nil
- case "Byte":
+ case "EchoByte":
return []interface{}{}, nil
- case "UInt32":
+ case "EchoUInt32":
return []interface{}{}, nil
- case "UInt64":
+ case "EchoUInt64":
return []interface{}{}, nil
case "InputArray":
return []interface{}{}, nil
@@ -489,7 +489,7 @@
func (__gen_s *ServerStubTypeTester) Signature(call _gen_ipc.ServerCall) (_gen_ipc.ServiceSignature, error) {
result := _gen_ipc.ServiceSignature{Methods: make(map[string]_gen_ipc.MethodSignature)}
- result.Methods["Bool"] = _gen_ipc.MethodSignature{
+ result.Methods["EchoBool"] = _gen_ipc.MethodSignature{
InArgs: []_gen_ipc.MethodArgument{
{Name: "I1", Type: 2},
},
@@ -498,7 +498,7 @@
{Name: "E", Type: 65},
},
}
- result.Methods["Byte"] = _gen_ipc.MethodSignature{
+ result.Methods["EchoByte"] = _gen_ipc.MethodSignature{
InArgs: []_gen_ipc.MethodArgument{
{Name: "I1", Type: 66},
},
@@ -507,7 +507,7 @@
{Name: "E", Type: 65},
},
}
- result.Methods["Float32"] = _gen_ipc.MethodSignature{
+ result.Methods["EchoFloat32"] = _gen_ipc.MethodSignature{
InArgs: []_gen_ipc.MethodArgument{
{Name: "I1", Type: 25},
},
@@ -516,7 +516,7 @@
{Name: "E", Type: 65},
},
}
- result.Methods["Float64"] = _gen_ipc.MethodSignature{
+ result.Methods["EchoFloat64"] = _gen_ipc.MethodSignature{
InArgs: []_gen_ipc.MethodArgument{
{Name: "I1", Type: 26},
},
@@ -525,6 +525,51 @@
{Name: "E", Type: 65},
},
}
+ result.Methods["EchoInt32"] = _gen_ipc.MethodSignature{
+ InArgs: []_gen_ipc.MethodArgument{
+ {Name: "I1", Type: 36},
+ },
+ OutArgs: []_gen_ipc.MethodArgument{
+ {Name: "O1", Type: 36},
+ {Name: "E", Type: 65},
+ },
+ }
+ result.Methods["EchoInt64"] = _gen_ipc.MethodSignature{
+ InArgs: []_gen_ipc.MethodArgument{
+ {Name: "I1", Type: 37},
+ },
+ OutArgs: []_gen_ipc.MethodArgument{
+ {Name: "O1", Type: 37},
+ {Name: "E", Type: 65},
+ },
+ }
+ result.Methods["EchoString"] = _gen_ipc.MethodSignature{
+ InArgs: []_gen_ipc.MethodArgument{
+ {Name: "I1", Type: 3},
+ },
+ OutArgs: []_gen_ipc.MethodArgument{
+ {Name: "O1", Type: 3},
+ {Name: "E", Type: 65},
+ },
+ }
+ result.Methods["EchoUInt32"] = _gen_ipc.MethodSignature{
+ InArgs: []_gen_ipc.MethodArgument{
+ {Name: "I1", Type: 52},
+ },
+ OutArgs: []_gen_ipc.MethodArgument{
+ {Name: "O1", Type: 52},
+ {Name: "E", Type: 65},
+ },
+ }
+ result.Methods["EchoUInt64"] = _gen_ipc.MethodSignature{
+ InArgs: []_gen_ipc.MethodArgument{
+ {Name: "I1", Type: 53},
+ },
+ OutArgs: []_gen_ipc.MethodArgument{
+ {Name: "O1", Type: 53},
+ {Name: "E", Type: 65},
+ },
+ }
result.Methods["InputArray"] = _gen_ipc.MethodSignature{
InArgs: []_gen_ipc.MethodArgument{
{Name: "I1", Type: 67},
@@ -557,24 +602,6 @@
{Name: "E", Type: 65},
},
}
- result.Methods["Int32"] = _gen_ipc.MethodSignature{
- InArgs: []_gen_ipc.MethodArgument{
- {Name: "I1", Type: 36},
- },
- OutArgs: []_gen_ipc.MethodArgument{
- {Name: "O1", Type: 36},
- {Name: "E", Type: 65},
- },
- }
- result.Methods["Int64"] = _gen_ipc.MethodSignature{
- InArgs: []_gen_ipc.MethodArgument{
- {Name: "I1", Type: 37},
- },
- OutArgs: []_gen_ipc.MethodArgument{
- {Name: "O1", Type: 37},
- {Name: "E", Type: 65},
- },
- }
result.Methods["MultipleArguments"] = _gen_ipc.MethodSignature{
InArgs: []_gen_ipc.MethodArgument{
{Name: "I1", Type: 36},
@@ -631,33 +658,6 @@
OutStream: 2,
}
- result.Methods["String"] = _gen_ipc.MethodSignature{
- InArgs: []_gen_ipc.MethodArgument{
- {Name: "I1", Type: 3},
- },
- OutArgs: []_gen_ipc.MethodArgument{
- {Name: "O1", Type: 3},
- {Name: "E", Type: 65},
- },
- }
- result.Methods["UInt32"] = _gen_ipc.MethodSignature{
- InArgs: []_gen_ipc.MethodArgument{
- {Name: "I1", Type: 52},
- },
- OutArgs: []_gen_ipc.MethodArgument{
- {Name: "O1", Type: 52},
- {Name: "E", Type: 65},
- },
- }
- result.Methods["UInt64"] = _gen_ipc.MethodSignature{
- InArgs: []_gen_ipc.MethodArgument{
- {Name: "I1", Type: 53},
- },
- OutArgs: []_gen_ipc.MethodArgument{
- {Name: "O1", Type: 53},
- {Name: "E", Type: 65},
- },
- }
result.TypeDefs = []_gen_vdl.Any{
_gen_wiretype.NamedPrimitiveType{Type: 0x1, Name: "error", Tags: []string(nil)}, _gen_wiretype.NamedPrimitiveType{Type: 0x32, Name: "byte", Tags: []string(nil)}, _gen_wiretype.ArrayType{Elem: 0x42, Len: 0x2, Name: "", Tags: []string(nil)}, _gen_wiretype.MapType{Key: 0x42, Elem: 0x42, Name: "", Tags: []string(nil)}, _gen_wiretype.SliceType{Elem: 0x42, Name: "", Tags: []string(nil)}, _gen_wiretype.StructType{
@@ -689,48 +689,48 @@
return
}
-func (__gen_s *ServerStubTypeTester) Bool(call _gen_ipc.ServerCall, I1 bool) (reply bool, err error) {
- reply, err = __gen_s.service.Bool(call, I1)
+func (__gen_s *ServerStubTypeTester) EchoBool(call _gen_ipc.ServerCall, I1 bool) (reply bool, err error) {
+ reply, err = __gen_s.service.EchoBool(call, I1)
return
}
-func (__gen_s *ServerStubTypeTester) Float32(call _gen_ipc.ServerCall, I1 float32) (reply float32, err error) {
- reply, err = __gen_s.service.Float32(call, I1)
+func (__gen_s *ServerStubTypeTester) EchoFloat32(call _gen_ipc.ServerCall, I1 float32) (reply float32, err error) {
+ reply, err = __gen_s.service.EchoFloat32(call, I1)
return
}
-func (__gen_s *ServerStubTypeTester) Float64(call _gen_ipc.ServerCall, I1 float64) (reply float64, err error) {
- reply, err = __gen_s.service.Float64(call, I1)
+func (__gen_s *ServerStubTypeTester) EchoFloat64(call _gen_ipc.ServerCall, I1 float64) (reply float64, err error) {
+ reply, err = __gen_s.service.EchoFloat64(call, I1)
return
}
-func (__gen_s *ServerStubTypeTester) Int32(call _gen_ipc.ServerCall, I1 int32) (reply int32, err error) {
- reply, err = __gen_s.service.Int32(call, I1)
+func (__gen_s *ServerStubTypeTester) EchoInt32(call _gen_ipc.ServerCall, I1 int32) (reply int32, err error) {
+ reply, err = __gen_s.service.EchoInt32(call, I1)
return
}
-func (__gen_s *ServerStubTypeTester) Int64(call _gen_ipc.ServerCall, I1 int64) (reply int64, err error) {
- reply, err = __gen_s.service.Int64(call, I1)
+func (__gen_s *ServerStubTypeTester) EchoInt64(call _gen_ipc.ServerCall, I1 int64) (reply int64, err error) {
+ reply, err = __gen_s.service.EchoInt64(call, I1)
return
}
-func (__gen_s *ServerStubTypeTester) String(call _gen_ipc.ServerCall, I1 string) (reply string, err error) {
- reply, err = __gen_s.service.String(call, I1)
+func (__gen_s *ServerStubTypeTester) EchoString(call _gen_ipc.ServerCall, I1 string) (reply string, err error) {
+ reply, err = __gen_s.service.EchoString(call, I1)
return
}
-func (__gen_s *ServerStubTypeTester) Byte(call _gen_ipc.ServerCall, I1 byte) (reply byte, err error) {
- reply, err = __gen_s.service.Byte(call, I1)
+func (__gen_s *ServerStubTypeTester) EchoByte(call _gen_ipc.ServerCall, I1 byte) (reply byte, err error) {
+ reply, err = __gen_s.service.EchoByte(call, I1)
return
}
-func (__gen_s *ServerStubTypeTester) UInt32(call _gen_ipc.ServerCall, I1 uint32) (reply uint32, err error) {
- reply, err = __gen_s.service.UInt32(call, I1)
+func (__gen_s *ServerStubTypeTester) EchoUInt32(call _gen_ipc.ServerCall, I1 uint32) (reply uint32, err error) {
+ reply, err = __gen_s.service.EchoUInt32(call, I1)
return
}
-func (__gen_s *ServerStubTypeTester) UInt64(call _gen_ipc.ServerCall, I1 uint64) (reply uint64, err error) {
- reply, err = __gen_s.service.UInt64(call, I1)
+func (__gen_s *ServerStubTypeTester) EchoUInt64(call _gen_ipc.ServerCall, I1 uint64) (reply uint64, err error) {
+ reply, err = __gen_s.service.EchoUInt64(call, I1)
return
}
