Checking in cmd files | first attempt at linking up item service

services/item/cmd/item/grpc.go

@@ -0,0 +1,81 @@
+package main
+
+import (
+	"context"
+	itempb "crossnokaye-interview-assignment/services/item/gen/grpc/item/pb"
+	itemsvr "crossnokaye-interview-assignment/services/item/gen/grpc/item/server"
+	item "crossnokaye-interview-assignment/services/item/gen/item"
+	"log"
+	"net"
+	"net/url"
+	"sync"
+
+	grpcmdlwr "goa.design/goa/v3/grpc/middleware"
+	"goa.design/goa/v3/middleware"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/reflection"
+)
+
+// handleGRPCServer starts configures and starts a gRPC server on the given
+// URL. It shuts down the server if any error is received in the error channel.
+func handleGRPCServer(ctx context.Context, u *url.URL, itemEndpoints *item.Endpoints, wg *sync.WaitGroup, errc chan error, logger *log.Logger, debug bool) {
+
+	// Setup goa log adapter.
+	var (
+		adapter middleware.Logger
+	)
+	{
+		adapter = middleware.NewLogger(logger)
+	}
+
+	// Wrap the endpoints with the transport specific layers. The generated
+	// server packages contains code generated from the design which maps
+	// the service input and output data structures to gRPC requests and
+	// responses.
+	var (
+		itemServer *itemsvr.Server
+	)
+	{
+		itemServer = itemsvr.New(itemEndpoints, nil)
+	}
+
+	// Initialize gRPC server with the middleware.
+	srv := grpc.NewServer(
+		grpc.ChainUnaryInterceptor(
+			grpcmdlwr.UnaryRequestID(),
+			grpcmdlwr.UnaryServerLog(adapter),
+		),
+	)
+
+	// Register the servers.
+	itempb.RegisterItemServer(srv, itemServer)
+
+	for svc, info := range srv.GetServiceInfo() {
+		for _, m := range info.Methods {
+			logger.Printf("serving gRPC method %s", svc+"/"+m.Name)
+		}
+	}
+
+	// Register the server reflection service on the server.
+	// See https://grpc.github.io/grpc/core/md_doc_server-reflection.html.
+	reflection.Register(srv)
+
+	(*wg).Add(1)
+	go func() {
+		defer (*wg).Done()
+
+		// Start gRPC server in a separate goroutine.
+		go func() {
+			lis, err := net.Listen("tcp", u.Host)
+			if err != nil {
+				errc <- err
+			}
+			logger.Printf("gRPC server listening on %q", u.Host)
+			errc <- srv.Serve(lis)
+		}()
+
+		<-ctx.Done()
+		logger.Printf("shutting down gRPC server at %q", u.Host)
+		srv.Stop()
+	}()
+}

services/item/cmd/item/main.go

@@ -0,0 +1,109 @@
+package main
+
+import (
+	"context"
+	itemapi "crossnokaye-interview-assignment/services/item"
+	item "crossnokaye-interview-assignment/services/item/gen/item"
+	"flag"
+	"fmt"
+	"log"
+	"net"
+	"net/url"
+	"os"
+	"os/signal"
+	"sync"
+	"syscall"
+)
+
+func main() {
+	// Define command line flags, add any other flag required to configure the
+	// service.
+	var (
+		hostF     = flag.String("host", "localhost", "Server host (valid values: localhost)")
+		domainF   = flag.String("domain", "", "Host domain name (overrides host domain specified in service design)")
+		grpcPortF = flag.String("grpc-port", "", "gRPC port (overrides host gRPC port specified in service design)")
+		secureF   = flag.Bool("secure", false, "Use secure scheme (https or grpcs)")
+		dbgF      = flag.Bool("debug", false, "Log request and response bodies")
+	)
+	flag.Parse()
+
+	// Setup logger. Replace logger with your own log package of choice.
+	var (
+		logger *log.Logger
+	)
+	{
+		logger = log.New(os.Stderr, "[itemapi] ", log.Ltime)
+	}
+
+	// Initialize the services.
+	var (
+		itemSvc item.Service
+	)
+	{
+		itemSvc = itemapi.NewItem(logger)
+	}
+
+	// Wrap the services in endpoints that can be invoked from other services
+	// potentially running in different processes.
+	var (
+		itemEndpoints *item.Endpoints
+	)
+	{
+		itemEndpoints = item.NewEndpoints(itemSvc)
+	}
+
+	// Create channel used by both the signal handler and server goroutines
+	// to notify the main goroutine when to stop the server.
+	errc := make(chan error)
+
+	// Setup interrupt handler. This optional step configures the process so
+	// that SIGINT and SIGTERM signals cause the services to stop gracefully.
+	go func() {
+		c := make(chan os.Signal, 1)
+		signal.Notify(c, syscall.SIGINT, syscall.SIGTERM)
+		errc <- fmt.Errorf("%s", <-c)
+	}()
+
+	var wg sync.WaitGroup
+	ctx, cancel := context.WithCancel(context.Background())
+
+	// Start the servers and send errors (if any) to the error channel.
+	switch *hostF {
+	case "localhost":
+		{
+			addr := "grpc://localhost:8082"
+			u, err := url.Parse(addr)
+			if err != nil {
+				logger.Fatalf("invalid URL %#v: %s\n", addr, err)
+			}
+			if *secureF {
+				u.Scheme = "grpcs"
+			}
+			if *domainF != "" {
+				u.Host = *domainF
+			}
+			if *grpcPortF != "" {
+				h, _, err := net.SplitHostPort(u.Host)
+				if err != nil {
+					logger.Fatalf("invalid URL %#v: %s\n", u.Host, err)
+				}
+				u.Host = net.JoinHostPort(h, *grpcPortF)
+			} else if u.Port() == "" {
+				u.Host = net.JoinHostPort(u.Host, "8080")
+			}
+			handleGRPCServer(ctx, u, itemEndpoints, &wg, errc, logger, *dbgF)
+		}
+
+	default:
+		logger.Fatalf("invalid host argument: %q (valid hosts: localhost)\n", *hostF)
+	}
+
+	// Wait for signal.
+	logger.Printf("exiting (%v)", <-errc)
+
+	// Send cancellation signal to the goroutines.
+	cancel()
+
+	wg.Wait()
+	logger.Println("exited")
+}