added client and modified transport layer for client endpoint

Author: amit

.gitignore

@@ -0,0 +1 @@
+microservices-with-gokit/.vscode/launch.json

microservices-with-gokit/calculator/client/client.go

@@ -0,0 +1,50 @@
+package client
+
+import (
+"github.com/go-kit/kit/endpoint"
+"github.com/go-kit/kit/sd"
+"github.com/go-kit/kit/sd/consul"
+"github.com/go-kit/kit/sd/lb"
+consulapi "github.com/hashicorp/consul/api"
+"io"
+"time"
+
+"github.com/amit1563/microservices-with-go/microservices-with-gokit/calculator"
+"github.com/go-kit/kit/log"
+)
+
+func New(serverAddr string, logger log.Logger) (calculatorservice.Service, error) {
+apiClient, err := consulapi.NewClient(&consulapi.Config{
+Address: serverAddr,
+})
+if err != nil {
+return nil, err
+}
+var (
+consulService = "calculatorservice"
+consulTags = []string{"DEV"}
+)
+var (
+sdclient = consul.NewClient(apiClient)
+instancer = consul.NewInstancer(sdclient, logger, consulService, consulTags, true)
+endpoints calculatorservice.Endpoints
+)
+{
+factory := factoryFor(calculatorservice.MakeAddEndpoint)
+endpointer := sd.NewEndpointer(instancer, factory, logger)
+balancer := lb.NewRoundRobin(endpointer)
+retry := lb.Retry(3, 500*time.Millisecond, balancer)
+endpoints.AddEndpoint = retry
+}
+return endpoints, nil
+}
+
+func factoryFor(makeEndpoint func(calculatorservice.Service) endpoint.Endpoint) sd.Factory {
+return func(serverAddr string) (endpoint.Endpoint, io.Closer, error) {
+service, err := calculatorservice.MakeClientEndpoints(serverAddr)
+if err != nil {
+return nil, nil, err
+}
+return makeEndpoint(service), nil, nil
+}
+}

microservices-with-gokit/calculator/endpoint.go

@@ -3,6 +3,9 @@ package calculatorservice
 import (
 "context"
 "github.com/go-kit/kit/endpoint"
+httptransport "github.com/go-kit/kit/transport/http"
+"net/url"
+"strings"
 )
 
 type Endpoints struct {
@@ -18,10 +21,41 @@ func MakeAddEndpoint(s Service) endpoint.Endpoint {
 return func(ctx context.Context, request interface{}) (interface{}, error) {
 req := request.(addRequest)
 //res := (addResponse)
-r, err := s.Add(req.X, req.Y)
+r, err := s.Add(ctx, req.X, req.Y)
 if err != nil {
 return addResponse{0, err}, err
 }
 return addResponse{r, nil}, nil
 }
 }
+
+func MakeClientEndpoints(target string) (Endpoints, error) {
+if !strings.HasPrefix(target, "http") {
+target = "http://" + target
+}
+
+tgt, err := url.Parse(target)
+
+if err != nil {
+return Endpoints{}, err
+}
+tgt.Path = ""
+
+options := []httptransport.ClientOption{}
+
+return Endpoints{
+AddEndpoint: httptransport.NewClient("GET", tgt, encodeAddRequest, decodeAddResponse, options...).Endpoint(),
+}, nil
+}
+
+// implement client endpoint
+
+func (e Endpoints) Add(ctx context.Context, x int, y int) (int, error) {
+req := addRequest{X: x, Y: y}
+res, err := e.AddEndpoint(ctx, req)
+if err != nil {
+return 0, nil
+}
+response := res.(addResponse)
+return response.Result, nil
+}

microservices-with-gokit/calculator/middleware.go

@@ -1,6 +1,7 @@
 package calculatorservice
 
 import (
+"context"
 "github.com/go-kit/kit/log"
 "time"
 )
@@ -21,9 +22,9 @@ type loggingMiddleware struct {
 logger log.Logger
 }
 
-func (mw loggingMiddleware) Add(x int, y int) (result int, err error) {
+func (mw loggingMiddleware) Add(ctx context.Context, x int, y int) (result int, err error) {
 defer func(begin time.Time) {
 mw.logger.Log("Method", "Add", "Result", result, "Took", time.Since(begin), "error", err)
 }(time.Now())
-return mw.next.Add(x, y)
+return mw.next.Add(ctx, x, y)
 }

microservices-with-gokit/calculator/server/server.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+"flag"
 "fmt"
 "github.com/amit1563/microservices-with-go/microservices-with-gokit/calculator"
 "github.com/go-kit/kit/log"
@@ -11,6 +12,10 @@ import (
 )
 
 func main() {
+var (
+httpAddr = flag.String("http.addr", ":8080", "HTTP listen address")
+)
+flag.Parse()
 
 var logger log.Logger
 {
@@ -28,14 +33,18 @@ func main() {
 {
 httpHandler = calculatorservice.MakeHTTPHandler(s, log.With(logger, "component", "http"))
 }
+// Interrupt handler.
 err := make(chan error)
 go func() {
 osSigChannel := make(chan os.Signal)
 signal.Notify(osSigChannel, syscall.SIGINT, syscall.SIGTERM)
 err <- fmt.Errorf("%s", <-osSigChannel)
 }()
+// HTTP transport.
 go func() {
-err <- http.ListenAndServe(":8080", httpHandler)
+err <- http.ListenAndServe(*httpAddr, httpHandler)
 }()
+// Run!
 logger.Log("lastcall", <-err)
+
 }

microservices-with-gokit/calculator/service.go

@@ -1,6 +1,7 @@
 package calculatorservice
 
 import (
+"context"
 "errors"
 "math"
 )
@@ -10,7 +11,7 @@ var (
 )
 
 type Service interface {
-Add(int, int) (int, error)
+Add(context.Context, int, int) (int, error)
 }
 
 type service struct {
@@ -20,7 +21,7 @@ func NewService() Service {
 return service{}
 }
 
-func (service) Add(x int, y int) (int, error) {
+func (service) Add(_ context.Context, x int, y int) (int, error) {
 if x > math.MaxInt16 || x-y > math.MaxInt16 {
 return 0, InternalServerErr
 }

microservices-with-gokit/calculator/transport.go

@@ -1,12 +1,14 @@
 package calculatorservice
 
 import (
+"bytes"
 "context"
 "encoding/json"
 "github.com/go-kit/kit/log"
 "github.com/go-kit/kit/transport"
 httptransport "github.com/go-kit/kit/transport/http"
 "github.com/gorilla/mux"
+"io/ioutil"
 "net/http"
 )
 
@@ -28,7 +30,16 @@ func MakeHTTPHandler(s Service, logger log.Logger) http.Handler {
 ))
 return r
 }
+func encodeAddRequest(ctx context.Context, req *http.Request, request interface{}) error {
 
+req.URL.Path = "/add/"
+return encodeRequest(ctx, req, request)
+}
+func decodeAddResponse(ctx context.Context, res *http.Response) (interface{}, error) {
+var response addResponse
+err := json.NewDecoder(res.Body).Decode(&response)
+return response, err
+}
 func decodeAddRequest(ctx context.Context, req *http.Request) (interface{}, error) {
 var r addRequest
 err := json.NewDecoder(req.Body).Decode(&r)
@@ -43,6 +54,15 @@ type errorer interface {
 error() error
 }
 
+func encodeRequest(_ context.Context, req *http.Request, request interface{}) error {
+var buf bytes.Buffer
+err := json.NewEncoder(&buf).Encode(request)
+if err != nil {
+return err
+}
+req.Body = ioutil.NopCloser(&buf)
+return nil
+}
 func encodeResponse(ctx context.Context, w http.ResponseWriter, response interface{}) error {
 if e, ok := response.(errorer); ok && e.error() != nil {
 // Not a Go kit transport error, but a business-logic error.