v1

package
v0.0.0-...-ae3c806 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 1, 2024 License: Apache-2.0 Imports: 12 Imported by: 1

Documentation

Overview

Package v1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func RegisterChangeHistoryHandler 

func RegisterChangeHistoryHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterChangeHistoryHandler registers the http handlers for service ChangeHistory to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterChangeHistoryHandlerClient 

func RegisterChangeHistoryHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extV1.ChangeHistoryClient) error

RegisterChangeHistoryHandlerClient registers the http handlers for service ChangeHistory to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "extV1.ChangeHistoryClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "extV1.ChangeHistoryClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "extV1.ChangeHistoryClient" to call the correct interceptors.

func RegisterChangeHistoryHandlerFromEndpoint 

func RegisterChangeHistoryHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterChangeHistoryHandlerFromEndpoint is same as RegisterChangeHistoryHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterChangeHistoryHandlerServer 

func RegisterChangeHistoryHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extV1.ChangeHistoryServer) error

RegisterChangeHistoryHandlerServer registers the http handlers for service ChangeHistory to "mux". UnaryRPC :call ChangeHistoryServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterChangeHistoryHandlerFromEndpoint instead.

func RegisterCloudServiceHandler 

func RegisterCloudServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterCloudServiceHandler registers the http handlers for service CloudService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterCloudServiceHandlerClient 

func RegisterCloudServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extV1.CloudServiceClient) error

RegisterCloudServiceHandlerClient registers the http handlers for service CloudService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "extV1.CloudServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "extV1.CloudServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "extV1.CloudServiceClient" to call the correct interceptors.

func RegisterCloudServiceHandlerFromEndpoint 

func RegisterCloudServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterCloudServiceHandlerFromEndpoint is same as RegisterCloudServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterCloudServiceHandlerServer 

func RegisterCloudServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extV1.CloudServiceServer) error

RegisterCloudServiceHandlerServer registers the http handlers for service CloudService to "mux". UnaryRPC :call CloudServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterCloudServiceHandlerFromEndpoint instead.

func RegisterCloudServiceQuerySetHandler 

func RegisterCloudServiceQuerySetHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterCloudServiceQuerySetHandler registers the http handlers for service CloudServiceQuerySet to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterCloudServiceQuerySetHandlerClient 

func RegisterCloudServiceQuerySetHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extV1.CloudServiceQuerySetClient) error

RegisterCloudServiceQuerySetHandlerClient registers the http handlers for service CloudServiceQuerySet to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "extV1.CloudServiceQuerySetClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "extV1.CloudServiceQuerySetClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "extV1.CloudServiceQuerySetClient" to call the correct interceptors.

func RegisterCloudServiceQuerySetHandlerFromEndpoint 

func RegisterCloudServiceQuerySetHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterCloudServiceQuerySetHandlerFromEndpoint is same as RegisterCloudServiceQuerySetHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterCloudServiceQuerySetHandlerServer 

func RegisterCloudServiceQuerySetHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extV1.CloudServiceQuerySetServer) error

RegisterCloudServiceQuerySetHandlerServer registers the http handlers for service CloudServiceQuerySet to "mux". UnaryRPC :call CloudServiceQuerySetServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterCloudServiceQuerySetHandlerFromEndpoint instead.

func RegisterCloudServiceReportHandler 

func RegisterCloudServiceReportHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterCloudServiceReportHandler registers the http handlers for service CloudServiceReport to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterCloudServiceReportHandlerClient 

func RegisterCloudServiceReportHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extV1.CloudServiceReportClient) error

RegisterCloudServiceReportHandlerClient registers the http handlers for service CloudServiceReport to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "extV1.CloudServiceReportClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "extV1.CloudServiceReportClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "extV1.CloudServiceReportClient" to call the correct interceptors.

func RegisterCloudServiceReportHandlerFromEndpoint 

func RegisterCloudServiceReportHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterCloudServiceReportHandlerFromEndpoint is same as RegisterCloudServiceReportHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterCloudServiceReportHandlerServer 

func RegisterCloudServiceReportHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extV1.CloudServiceReportServer) error

RegisterCloudServiceReportHandlerServer registers the http handlers for service CloudServiceReport to "mux". UnaryRPC :call CloudServiceReportServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterCloudServiceReportHandlerFromEndpoint instead.

func RegisterCloudServiceStatsHandler 

func RegisterCloudServiceStatsHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterCloudServiceStatsHandler registers the http handlers for service CloudServiceStats to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterCloudServiceStatsHandlerClient 

func RegisterCloudServiceStatsHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extV1.CloudServiceStatsClient) error

RegisterCloudServiceStatsHandlerClient registers the http handlers for service CloudServiceStats to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "extV1.CloudServiceStatsClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "extV1.CloudServiceStatsClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "extV1.CloudServiceStatsClient" to call the correct interceptors.

func RegisterCloudServiceStatsHandlerFromEndpoint 

func RegisterCloudServiceStatsHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterCloudServiceStatsHandlerFromEndpoint is same as RegisterCloudServiceStatsHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterCloudServiceStatsHandlerServer 

func RegisterCloudServiceStatsHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extV1.CloudServiceStatsServer) error

RegisterCloudServiceStatsHandlerServer registers the http handlers for service CloudServiceStats to "mux". UnaryRPC :call CloudServiceStatsServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterCloudServiceStatsHandlerFromEndpoint instead.

func RegisterCloudServiceTypeHandler 

func RegisterCloudServiceTypeHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterCloudServiceTypeHandler registers the http handlers for service CloudServiceType to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterCloudServiceTypeHandlerClient 

func RegisterCloudServiceTypeHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extV1.CloudServiceTypeClient) error

RegisterCloudServiceTypeHandlerClient registers the http handlers for service CloudServiceType to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "extV1.CloudServiceTypeClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "extV1.CloudServiceTypeClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "extV1.CloudServiceTypeClient" to call the correct interceptors.

func RegisterCloudServiceTypeHandlerFromEndpoint 

func RegisterCloudServiceTypeHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterCloudServiceTypeHandlerFromEndpoint is same as RegisterCloudServiceTypeHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterCloudServiceTypeHandlerServer 

func RegisterCloudServiceTypeHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extV1.CloudServiceTypeServer) error

RegisterCloudServiceTypeHandlerServer registers the http handlers for service CloudServiceType to "mux". UnaryRPC :call CloudServiceTypeServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterCloudServiceTypeHandlerFromEndpoint instead.

func RegisterCollectorHandler 

func RegisterCollectorHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterCollectorHandler registers the http handlers for service Collector to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterCollectorHandlerClient 

func RegisterCollectorHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extV1.CollectorClient) error

RegisterCollectorHandlerClient registers the http handlers for service Collector to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "extV1.CollectorClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "extV1.CollectorClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "extV1.CollectorClient" to call the correct interceptors.

func RegisterCollectorHandlerFromEndpoint 

func RegisterCollectorHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterCollectorHandlerFromEndpoint is same as RegisterCollectorHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterCollectorHandlerServer 

func RegisterCollectorHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extV1.CollectorServer) error

RegisterCollectorHandlerServer registers the http handlers for service Collector to "mux". UnaryRPC :call CollectorServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterCollectorHandlerFromEndpoint instead.

func RegisterCollectorRuleHandler 

func RegisterCollectorRuleHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterCollectorRuleHandler registers the http handlers for service CollectorRule to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterCollectorRuleHandlerClient 

func RegisterCollectorRuleHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extV1.CollectorRuleClient) error

RegisterCollectorRuleHandlerClient registers the http handlers for service CollectorRule to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "extV1.CollectorRuleClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "extV1.CollectorRuleClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "extV1.CollectorRuleClient" to call the correct interceptors.

func RegisterCollectorRuleHandlerFromEndpoint 

func RegisterCollectorRuleHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterCollectorRuleHandlerFromEndpoint is same as RegisterCollectorRuleHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterCollectorRuleHandlerServer 

func RegisterCollectorRuleHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extV1.CollectorRuleServer) error

RegisterCollectorRuleHandlerServer registers the http handlers for service CollectorRule to "mux". UnaryRPC :call CollectorRuleServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterCollectorRuleHandlerFromEndpoint instead.

func RegisterJobHandler 

func RegisterJobHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterJobHandler registers the http handlers for service Job to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterJobHandlerClient 

func RegisterJobHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extV1.JobClient) error

RegisterJobHandlerClient registers the http handlers for service Job to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "extV1.JobClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "extV1.JobClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "extV1.JobClient" to call the correct interceptors.

func RegisterJobHandlerFromEndpoint 

func RegisterJobHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterJobHandlerFromEndpoint is same as RegisterJobHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterJobHandlerServer 

func RegisterJobHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extV1.JobServer) error

RegisterJobHandlerServer registers the http handlers for service Job to "mux". UnaryRPC :call JobServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterJobHandlerFromEndpoint instead.

func RegisterJobTaskHandler 

func RegisterJobTaskHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterJobTaskHandler registers the http handlers for service JobTask to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterJobTaskHandlerClient 

func RegisterJobTaskHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extV1.JobTaskClient) error

RegisterJobTaskHandlerClient registers the http handlers for service JobTask to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "extV1.JobTaskClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "extV1.JobTaskClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "extV1.JobTaskClient" to call the correct interceptors.

func RegisterJobTaskHandlerFromEndpoint 

func RegisterJobTaskHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterJobTaskHandlerFromEndpoint is same as RegisterJobTaskHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterJobTaskHandlerServer 

func RegisterJobTaskHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extV1.JobTaskServer) error

RegisterJobTaskHandlerServer registers the http handlers for service JobTask to "mux". UnaryRPC :call JobTaskServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterJobTaskHandlerFromEndpoint instead.

func RegisterMetricDataHandler 

func RegisterMetricDataHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterMetricDataHandler registers the http handlers for service MetricData to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterMetricDataHandlerClient 

func RegisterMetricDataHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extV1.MetricDataClient) error

RegisterMetricDataHandlerClient registers the http handlers for service MetricData to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "extV1.MetricDataClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "extV1.MetricDataClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "extV1.MetricDataClient" to call the correct interceptors.

func RegisterMetricDataHandlerFromEndpoint 

func RegisterMetricDataHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterMetricDataHandlerFromEndpoint is same as RegisterMetricDataHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterMetricDataHandlerServer 

func RegisterMetricDataHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extV1.MetricDataServer) error

RegisterMetricDataHandlerServer registers the http handlers for service MetricData to "mux". UnaryRPC :call MetricDataServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterMetricDataHandlerFromEndpoint instead.

func RegisterMetricExampleHandler 

func RegisterMetricExampleHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterMetricExampleHandler registers the http handlers for service MetricExample to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterMetricExampleHandlerClient 

func RegisterMetricExampleHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extV1.MetricExampleClient) error

RegisterMetricExampleHandlerClient registers the http handlers for service MetricExample to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "extV1.MetricExampleClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "extV1.MetricExampleClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "extV1.MetricExampleClient" to call the correct interceptors.

func RegisterMetricExampleHandlerFromEndpoint 

func RegisterMetricExampleHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterMetricExampleHandlerFromEndpoint is same as RegisterMetricExampleHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterMetricExampleHandlerServer 

func RegisterMetricExampleHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extV1.MetricExampleServer) error

RegisterMetricExampleHandlerServer registers the http handlers for service MetricExample to "mux". UnaryRPC :call MetricExampleServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterMetricExampleHandlerFromEndpoint instead.

func RegisterMetricHandler 

func RegisterMetricHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterMetricHandler registers the http handlers for service Metric to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterMetricHandlerClient 

func RegisterMetricHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extV1.MetricClient) error

RegisterMetricHandlerClient registers the http handlers for service Metric to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "extV1.MetricClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "extV1.MetricClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "extV1.MetricClient" to call the correct interceptors.

func RegisterMetricHandlerFromEndpoint 

func RegisterMetricHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterMetricHandlerFromEndpoint is same as RegisterMetricHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterMetricHandlerServer 

func RegisterMetricHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extV1.MetricServer) error

RegisterMetricHandlerServer registers the http handlers for service Metric to "mux". UnaryRPC :call MetricServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterMetricHandlerFromEndpoint instead.

func RegisterNamespaceHandler 

func RegisterNamespaceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterNamespaceHandler registers the http handlers for service Namespace to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterNamespaceHandlerClient 

func RegisterNamespaceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extV1.NamespaceClient) error

RegisterNamespaceHandlerClient registers the http handlers for service Namespace to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "extV1.NamespaceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "extV1.NamespaceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "extV1.NamespaceClient" to call the correct interceptors.

func RegisterNamespaceHandlerFromEndpoint 

func RegisterNamespaceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterNamespaceHandlerFromEndpoint is same as RegisterNamespaceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterNamespaceHandlerServer 

func RegisterNamespaceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extV1.NamespaceServer) error

RegisterNamespaceHandlerServer registers the http handlers for service Namespace to "mux". UnaryRPC :call NamespaceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterNamespaceHandlerFromEndpoint instead.

func RegisterNoteHandler 

func RegisterNoteHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterNoteHandler registers the http handlers for service Note to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterNoteHandlerClient 

func RegisterNoteHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extV1.NoteClient) error

RegisterNoteHandlerClient registers the http handlers for service Note to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "extV1.NoteClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "extV1.NoteClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "extV1.NoteClient" to call the correct interceptors.

func RegisterNoteHandlerFromEndpoint 

func RegisterNoteHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterNoteHandlerFromEndpoint is same as RegisterNoteHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterNoteHandlerServer 

func RegisterNoteHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extV1.NoteServer) error

RegisterNoteHandlerServer registers the http handlers for service Note to "mux". UnaryRPC :call NoteServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterNoteHandlerFromEndpoint instead.

func RegisterRegionHandler 

func RegisterRegionHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterRegionHandler registers the http handlers for service Region to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterRegionHandlerClient 

func RegisterRegionHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extV1.RegionClient) error

RegisterRegionHandlerClient registers the http handlers for service Region to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "extV1.RegionClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "extV1.RegionClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "extV1.RegionClient" to call the correct interceptors.

func RegisterRegionHandlerFromEndpoint 

func RegisterRegionHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterRegionHandlerFromEndpoint is same as RegisterRegionHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterRegionHandlerServer 

func RegisterRegionHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extV1.RegionServer) error

RegisterRegionHandlerServer registers the http handlers for service Region to "mux". UnaryRPC :call RegionServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterRegionHandlerFromEndpoint instead.

Types

This section is empty.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.