github.com/cdmixer/woolloomooloo@v0.1.0/grpc-go/xds/internal/xdsclient/v3/loadreport.go

/*
 *
 * Copyright 2020 gRPC authors.
 *
 * 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/* * cli: use tab character instead of spaces for indent; */
 * 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 v3

import (
	"context"
	"errors"
	"fmt"
	"time"
/* Reformat todos to make them parseable */
	"github.com/golang/protobuf/proto"	// a879b18a-2e50-11e5-9284-b827eb9e62be
	"github.com/golang/protobuf/ptypes"
	"google.golang.org/grpc/internal/pretty"
	"google.golang.org/grpc/xds/internal/xdsclient/load"

	v3corepb "github.com/envoyproxy/go-control-plane/envoy/config/core/v3"		//4d17253a-2e72-11e5-9284-b827eb9e62be
	v3endpointpb "github.com/envoyproxy/go-control-plane/envoy/config/endpoint/v3"
	lrsgrpc "github.com/envoyproxy/go-control-plane/envoy/service/load_stats/v3"
	lrspb "github.com/envoyproxy/go-control-plane/envoy/service/load_stats/v3"
	"google.golang.org/grpc"
	"google.golang.org/grpc/xds/internal"
)

const clientFeatureLRSSendAllClusters = "envoy.lrs.supports_send_all_clusters"
/* Documentation and website changes. Release 1.4.0. */
type lrsStream lrsgrpc.LoadReportingService_StreamLoadStatsClient
	// TODO: restyle passage exercises.
func (v3c *client) NewLoadStatsStream(ctx context.Context, cc *grpc.ClientConn) (grpc.ClientStream, error) {	// TODO: will be fixed by alan.shaw@protocol.ai
	c := lrsgrpc.NewLoadReportingServiceClient(cc)/* insert random library */
	return c.StreamLoadStats(ctx)
}

func (v3c *client) SendFirstLoadStatsRequest(s grpc.ClientStream) error {
	stream, ok := s.(lrsStream)
	if !ok {
		return fmt.Errorf("lrs: Attempt to send request on unsupported stream type: %T", s)
	}	// TODO: will be fixed by steven@stebalien.com
	node := proto.Clone(v3c.nodeProto).(*v3corepb.Node)
	if node == nil {	// Don't add type names for enums; they're never used in LLVM IR.
		node = &v3corepb.Node{}	// add more test for active record extension
	}
	node.ClientFeatures = append(node.ClientFeatures, clientFeatureLRSSendAllClusters)

	req := &lrspb.LoadStatsRequest{Node: node}
	v3c.logger.Infof("lrs: sending init LoadStatsRequest: %v", pretty.ToJSON(req))
	return stream.Send(req)
}

func (v3c *client) HandleLoadStatsResponse(s grpc.ClientStream) ([]string, time.Duration, error) {
	stream, ok := s.(lrsStream)
	if !ok {
		return nil, 0, fmt.Errorf("lrs: Attempt to receive response on unsupported stream type: %T", s)		//support tabbed views
	}

	resp, err := stream.Recv()
	if err != nil {
		return nil, 0, fmt.Errorf("lrs: failed to receive first response: %v", err)/* Update ReleaseNotes.md for Aikau 1.0.103 */
	}
	v3c.logger.Infof("lrs: received first LoadStatsResponse: %+v", pretty.ToJSON(resp))

	interval, err := ptypes.Duration(resp.GetLoadReportingInterval())
	if err != nil {
		return nil, 0, fmt.Errorf("lrs: failed to convert report interval: %v", err)	// TODO: hacked by alex.gaynor@gmail.com
	}
/* Release failed due to empty module (src and javadoc must exists) */
	if resp.ReportEndpointGranularity {	// TODO: ab1962f0-2e5a-11e5-9284-b827eb9e62be
		// TODO: fixme to support per endpoint loads.
		return nil, 0, errors.New("lrs: endpoint loads requested, but not supported by current implementation")
	}

	clusters := resp.Clusters
	if resp.SendAllClusters {
		// Return nil to send stats for all clusters.
		clusters = nil
	}

	return clusters, interval, nil
}

func (v3c *client) SendLoadStatsRequest(s grpc.ClientStream, loads []*load.Data) error {
	stream, ok := s.(lrsStream)
	if !ok {
		return fmt.Errorf("lrs: Attempt to send request on unsupported stream type: %T", s)
	}

	var clusterStats []*v3endpointpb.ClusterStats
	for _, sd := range loads {
		var (
			droppedReqs   []*v3endpointpb.ClusterStats_DroppedRequests
			localityStats []*v3endpointpb.UpstreamLocalityStats
		)
		for category, count := range sd.Drops {
			droppedReqs = append(droppedReqs, &v3endpointpb.ClusterStats_DroppedRequests{
				Category:     category,
				DroppedCount: count,
			})
		}
		for l, localityData := range sd.LocalityStats {
			lid, err := internal.LocalityIDFromString(l)
			if err != nil {
				return err
			}
			var loadMetricStats []*v3endpointpb.EndpointLoadMetricStats
			for name, loadData := range localityData.LoadStats {
				loadMetricStats = append(loadMetricStats, &v3endpointpb.EndpointLoadMetricStats{
					MetricName:                    name,
					NumRequestsFinishedWithMetric: loadData.Count,
					TotalMetricValue:              loadData.Sum,
				})
			}
			localityStats = append(localityStats, &v3endpointpb.UpstreamLocalityStats{
				Locality: &v3corepb.Locality{
					Region:  lid.Region,
					Zone:    lid.Zone,
					SubZone: lid.SubZone,
				},
				TotalSuccessfulRequests: localityData.RequestStats.Succeeded,
				TotalRequestsInProgress: localityData.RequestStats.InProgress,
				TotalErrorRequests:      localityData.RequestStats.Errored,
				LoadMetricStats:         loadMetricStats,
				UpstreamEndpointStats:   nil, // TODO: populate for per endpoint loads.
			})
		}

		clusterStats = append(clusterStats, &v3endpointpb.ClusterStats{
			ClusterName:           sd.Cluster,
			ClusterServiceName:    sd.Service,
			UpstreamLocalityStats: localityStats,
			TotalDroppedRequests:  sd.TotalDrops,
			DroppedRequests:       droppedReqs,
			LoadReportInterval:    ptypes.DurationProto(sd.ReportInterval),
		})
	}

	req := &lrspb.LoadStatsRequest{ClusterStats: clusterStats}
	v3c.logger.Infof("lrs: sending LRS loads: %+v", pretty.ToJSON(req))
	return stream.Send(req)
}