Add a Ping() method to the trace service to make it easier to detect if the service is up and runni…

trace/service/impl.go

 package traceservice
 
 // Generate the go code from the protocol buffer definitions.
 //go:generate protoc --go_out=plugins=grpc:. traceservice.proto
 
 import (
         "bytes"
         "encoding/binary"
         "fmt"
         "strings"
@@ skipping 282 matching lines @@
                         }
                 }
                 return nil
         }
         if err := ts.db.View(get); err != nil {
                 return nil, fmt.Errorf("Failed to add values to tracedb: %s", err)
         }
         return resp, nil
 }
 
-func (ts *TraceServiceImpl) AddParams(ctx context.Context, in *AddParamsRequest) (*EmptyResponse, error) {
+func (ts *TraceServiceImpl) AddParams(ctx context.Context, in *AddParamsRequest) (*Empty, error) {
         // Serialize the Params for each trace as a proto and collect the traceids.
         // We do this outside the add func so there's less work taking place in the
         // Update transaction.
         params := map[string][]byte{}
         var err error
         for key, value := range in.Params {
                 ti := &StoredEntry{
                         Params: value,
                 }
                 params[key], err = proto.Marshal(ti)
                 if err != nil {
                         return nil, fmt.Errorf("Failed to serialize the Params: %s", err)
                 }
         }
 
         // Add the Params for each traceid to the bucket.
         add := func(tx *bolt.Tx) error {
                 t := tx.Bucket([]byte(TRACE_BUCKET_NAME))
                 for traceid, _ := range in.Params {
                         if err := t.Put([]byte(traceid), params[traceid]); err != nil {
                                 return fmt.Errorf("Failed to write the trace info for %s: %s", traceid, err)
                         }
                 }
                 return nil
         }
         if err := ts.db.Update(add); err != nil {
                 return nil, fmt.Errorf("Failed to add values to tracedb: %s", err)
         }
-        return &EmptyResponse{}, nil
+        return &Empty{}, nil
 }
 
-func (ts *TraceServiceImpl) Add(ctx context.Context, in *AddRequest) (*EmptyResponse, error) {
+func (ts *TraceServiceImpl) Add(ctx context.Context, in *AddRequest) (*Empty, error) {
         glog.Info("Add() begin.")
         if in == nil {
                 return nil, fmt.Errorf("Received nil request.")
         }
         if in.Commitid == nil {
                 return nil, fmt.Errorf("Received nil CommitID")
         }
         if in.Entries == nil {
                 return nil, fmt.Errorf("Received nil Entries")
         }
@@ skipping 33 matching lines @@
                 // Write to the datastore.
                 if err := c.Put(key, data.ToBytes()); err != nil {
                         return fmt.Errorf("Failed to write the trace info for %s: %s", key, err)
                 }
                 return nil
         }
 
         if err := ts.db.Update(add); err != nil {
                 return nil, fmt.Errorf("Failed to add values to tracedb: %s", err)
         }
-        return &EmptyResponse{}, nil
+        return &Empty{}, nil
 }
 
-func (ts *TraceServiceImpl) Remove(ctx context.Context, in *RemoveRequest) (*EmptyResponse, error) {
+func (ts *TraceServiceImpl) Remove(ctx context.Context, in *RemoveRequest) (*Empty, error) {
         if in == nil {
                 return nil, fmt.Errorf("Received nil request.")
         }
         remove := func(tx *bolt.Tx) error {
                 c := tx.Bucket([]byte(COMMIT_BUCKET_NAME))
                 key, err := CommitIDToBytes(in.Commitid)
                 if err != nil {
                         return err
                 }
                 return c.Delete(key)
         }
         if err := ts.db.Update(remove); err != nil {
                 return nil, fmt.Errorf("Failed to remove values from tracedb: %s", err)
         }
-        ret := &EmptyResponse{}
+        ret := &Empty{}
         return ret, nil
 }
 
 func (ts *TraceServiceImpl) List(ctx context.Context, listRequest *ListRequest) (*ListResponse, error) {
         if listRequest == nil {
                 return nil, fmt.Errorf("Received nil request.")
         }
         // Convert the begin and end timestamps into RFC3339 strings we can use for prefix matching.
         begin := []byte(time.Unix(listRequest.Begin, 0).Format(time.RFC3339))
         end := []byte(time.Unix(listRequest.End, 0).Format(time.RFC3339))
@@ skipping 92 matching lines @@
 
                 return nil
         }
         if err := ts.db.View(load); err != nil {
                 return nil, fmt.Errorf("GetParams: Failed to load data: %s", err)
         }
 
         return ret, nil
 }
 
+func (ts *TraceServiceImpl) Ping(ctx context.Context, empty *Empty) (*Empty, error) {
+        return &Empty{}, nil
+}
+
 // Close closes the underlying datastore and it not part of the TraceServiceServer interface.
 func (ts *TraceServiceImpl) Close() error {
         return ts.db.Close()
 }