299 lines
8.0 KiB
Go
299 lines
8.0 KiB
Go
// Copyright 2018 Google LLC
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"flag"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"net"
|
|
"os"
|
|
"os/signal"
|
|
"strings"
|
|
"sync"
|
|
"syscall"
|
|
"time"
|
|
|
|
pb "github.com/GoogleCloudPlatform/microservices-demo/src/productcatalogservice/genproto"
|
|
healthpb "google.golang.org/grpc/health/grpc_health_v1"
|
|
|
|
"cloud.google.com/go/profiler"
|
|
"contrib.go.opencensus.io/exporter/stackdriver"
|
|
"github.com/golang/protobuf/jsonpb"
|
|
"github.com/sirupsen/logrus"
|
|
"go.opencensus.io/exporter/jaeger"
|
|
"go.opencensus.io/plugin/ocgrpc"
|
|
"go.opencensus.io/stats/view"
|
|
"go.opencensus.io/trace"
|
|
"google.golang.org/grpc"
|
|
"google.golang.org/grpc/codes"
|
|
"google.golang.org/grpc/status"
|
|
)
|
|
|
|
var (
|
|
cat pb.ListProductsResponse
|
|
catalogMutex *sync.Mutex
|
|
log *logrus.Logger
|
|
extraLatency time.Duration
|
|
|
|
port = "3550"
|
|
|
|
reloadCatalog bool
|
|
)
|
|
|
|
func init() {
|
|
log = logrus.New()
|
|
log.Formatter = &logrus.JSONFormatter{
|
|
FieldMap: logrus.FieldMap{
|
|
logrus.FieldKeyTime: "timestamp",
|
|
logrus.FieldKeyLevel: "severity",
|
|
logrus.FieldKeyMsg: "message",
|
|
},
|
|
TimestampFormat: time.RFC3339Nano,
|
|
}
|
|
log.Out = os.Stdout
|
|
catalogMutex = &sync.Mutex{}
|
|
err := readCatalogFile(&cat)
|
|
if err != nil {
|
|
log.Warnf("could not parse product catalog")
|
|
}
|
|
}
|
|
|
|
func main() {
|
|
if os.Getenv("DISABLE_TRACING") == "" {
|
|
log.Info("Tracing enabled.")
|
|
go initTracing()
|
|
} else {
|
|
log.Info("Tracing disabled.")
|
|
}
|
|
|
|
if os.Getenv("DISABLE_PROFILER") == "" {
|
|
log.Info("Profiling enabled.")
|
|
go initProfiling("productcatalogservice", "1.0.0")
|
|
} else {
|
|
log.Info("Profiling disabled.")
|
|
}
|
|
|
|
flag.Parse()
|
|
|
|
// set injected latency
|
|
if s := os.Getenv("EXTRA_LATENCY"); s != "" {
|
|
v, err := time.ParseDuration(s)
|
|
if err != nil {
|
|
log.Fatalf("failed to parse EXTRA_LATENCY (%s) as time.Duration: %+v", v, err)
|
|
}
|
|
extraLatency = v
|
|
log.Infof("extra latency enabled (duration: %v)", extraLatency)
|
|
} else {
|
|
extraLatency = time.Duration(0)
|
|
}
|
|
|
|
sigs := make(chan os.Signal, 1)
|
|
signal.Notify(sigs, syscall.SIGUSR1, syscall.SIGUSR2)
|
|
go func() {
|
|
for {
|
|
sig := <-sigs
|
|
log.Printf("Received signal: %s", sig)
|
|
if sig == syscall.SIGUSR1 {
|
|
reloadCatalog = true
|
|
log.Infof("Enable catalog reloading")
|
|
} else {
|
|
reloadCatalog = false
|
|
log.Infof("Disable catalog reloading")
|
|
}
|
|
}
|
|
}()
|
|
|
|
if os.Getenv("PORT") != "" {
|
|
port = os.Getenv("PORT")
|
|
}
|
|
log.Infof("starting grpc server at :%s", port)
|
|
run(port)
|
|
select {}
|
|
}
|
|
|
|
func run(port string) string {
|
|
l, err := net.Listen("tcp", fmt.Sprintf(":%s", port))
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
var srv *grpc.Server
|
|
if os.Getenv("DISABLE_STATS") == "" {
|
|
log.Info("Stats enabled.")
|
|
srv = grpc.NewServer(grpc.StatsHandler(&ocgrpc.ServerHandler{}))
|
|
} else {
|
|
log.Info("Stats disabled.")
|
|
srv = grpc.NewServer()
|
|
}
|
|
|
|
svc := &productCatalog{}
|
|
|
|
pb.RegisterProductCatalogServiceServer(srv, svc)
|
|
healthpb.RegisterHealthServer(srv, svc)
|
|
go srv.Serve(l)
|
|
return l.Addr().String()
|
|
}
|
|
|
|
func initJaegerTracing() {
|
|
svcAddr := os.Getenv("JAEGER_SERVICE_ADDR")
|
|
if svcAddr == "" {
|
|
log.Info("jaeger initialization disabled.")
|
|
return
|
|
}
|
|
// Register the Jaeger exporter to be able to retrieve
|
|
// the collected spans.
|
|
exporter, err := jaeger.NewExporter(jaeger.Options{
|
|
Endpoint: fmt.Sprintf("http://%s", svcAddr),
|
|
Process: jaeger.Process{
|
|
ServiceName: "productcatalogservice",
|
|
},
|
|
})
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
trace.RegisterExporter(exporter)
|
|
log.Info("jaeger initialization completed.")
|
|
}
|
|
|
|
func initStats(exporter *stackdriver.Exporter) {
|
|
view.SetReportingPeriod(60 * time.Second)
|
|
view.RegisterExporter(exporter)
|
|
if err := view.Register(ocgrpc.DefaultServerViews...); err != nil {
|
|
log.Info("Error registering default server views")
|
|
} else {
|
|
log.Info("Registered default server views")
|
|
}
|
|
}
|
|
|
|
func initStackdriverTracing() {
|
|
// TODO(ahmetb) this method is duplicated in other microservices using Go
|
|
// since they are not sharing packages.
|
|
for i := 1; i <= 3; i++ {
|
|
exporter, err := stackdriver.NewExporter(stackdriver.Options{})
|
|
if err != nil {
|
|
log.Warnf("failed to initialize Stackdriver exporter: %+v", err)
|
|
} else {
|
|
trace.RegisterExporter(exporter)
|
|
trace.ApplyConfig(trace.Config{DefaultSampler: trace.AlwaysSample()})
|
|
log.Info("registered Stackdriver tracing")
|
|
|
|
// Register the views to collect server stats.
|
|
initStats(exporter)
|
|
return
|
|
}
|
|
d := time.Second * 10 * time.Duration(i)
|
|
log.Infof("sleeping %v to retry initializing Stackdriver exporter", d)
|
|
time.Sleep(d)
|
|
}
|
|
log.Warn("could not initialize Stackdriver exporter after retrying, giving up")
|
|
}
|
|
|
|
func initTracing() {
|
|
initJaegerTracing()
|
|
initStackdriverTracing()
|
|
}
|
|
|
|
func initProfiling(service, version string) {
|
|
// TODO(ahmetb) this method is duplicated in other microservices using Go
|
|
// since they are not sharing packages.
|
|
for i := 1; i <= 3; i++ {
|
|
if err := profiler.Start(profiler.Config{
|
|
Service: service,
|
|
ServiceVersion: version,
|
|
// ProjectID must be set if not running on GCP.
|
|
// ProjectID: "my-project",
|
|
}); err != nil {
|
|
log.Warnf("failed to start profiler: %+v", err)
|
|
} else {
|
|
log.Info("started Stackdriver profiler")
|
|
return
|
|
}
|
|
d := time.Second * 10 * time.Duration(i)
|
|
log.Infof("sleeping %v to retry initializing Stackdriver profiler", d)
|
|
time.Sleep(d)
|
|
}
|
|
log.Warn("could not initialize Stackdriver profiler after retrying, giving up")
|
|
}
|
|
|
|
type productCatalog struct{}
|
|
|
|
func readCatalogFile(catalog *pb.ListProductsResponse) error {
|
|
catalogMutex.Lock()
|
|
defer catalogMutex.Unlock()
|
|
catalogJSON, err := ioutil.ReadFile("products.json")
|
|
if err != nil {
|
|
log.Fatalf("failed to open product catalog json file: %v", err)
|
|
return err
|
|
}
|
|
if err := jsonpb.Unmarshal(bytes.NewReader(catalogJSON), catalog); err != nil {
|
|
log.Warnf("failed to parse the catalog JSON: %v", err)
|
|
return err
|
|
}
|
|
log.Info("successfully parsed product catalog json")
|
|
return nil
|
|
}
|
|
|
|
func parseCatalog() []*pb.Product {
|
|
if reloadCatalog || len(cat.Products) == 0 {
|
|
err := readCatalogFile(&cat)
|
|
if err != nil {
|
|
return []*pb.Product{}
|
|
}
|
|
}
|
|
return cat.Products
|
|
}
|
|
|
|
func (p *productCatalog) Check(ctx context.Context, req *healthpb.HealthCheckRequest) (*healthpb.HealthCheckResponse, error) {
|
|
return &healthpb.HealthCheckResponse{Status: healthpb.HealthCheckResponse_SERVING}, nil
|
|
}
|
|
|
|
func (p *productCatalog) Watch(req *healthpb.HealthCheckRequest, ws healthpb.Health_WatchServer) error {
|
|
return status.Errorf(codes.Unimplemented, "health check via Watch not implemented")
|
|
}
|
|
|
|
func (p *productCatalog) ListProducts(context.Context, *pb.Empty) (*pb.ListProductsResponse, error) {
|
|
time.Sleep(extraLatency)
|
|
return &pb.ListProductsResponse{Products: parseCatalog()}, nil
|
|
}
|
|
|
|
func (p *productCatalog) GetProduct(ctx context.Context, req *pb.GetProductRequest) (*pb.Product, error) {
|
|
time.Sleep(extraLatency)
|
|
var found *pb.Product
|
|
for i := 0; i < len(parseCatalog()); i++ {
|
|
if req.Id == parseCatalog()[i].Id {
|
|
found = parseCatalog()[i]
|
|
}
|
|
}
|
|
if found == nil {
|
|
return nil, status.Errorf(codes.NotFound, "no product with ID %s", req.Id)
|
|
}
|
|
return found, nil
|
|
}
|
|
|
|
func (p *productCatalog) SearchProducts(ctx context.Context, req *pb.SearchProductsRequest) (*pb.SearchProductsResponse, error) {
|
|
time.Sleep(extraLatency)
|
|
// Intepret query as a substring match in name or description.
|
|
var ps []*pb.Product
|
|
for _, p := range parseCatalog() {
|
|
if strings.Contains(strings.ToLower(p.Name), strings.ToLower(req.Query)) ||
|
|
strings.Contains(strings.ToLower(p.Description), strings.ToLower(req.Query)) {
|
|
ps = append(ps, p)
|
|
}
|
|
}
|
|
return &pb.SearchProductsResponse{Results: ps}, nil
|
|
}
|