v1

package
v0.0.0-...-729b752 Latest Latest
Warning

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

 Go to latest Published: Jun 18, 2024 License: Apache-2.0 Imports: 12 Imported by: 0

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.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func RegisterAlertHandler 

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

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

func RegisterAlertHandlerClient 

func RegisterAlertHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extV1.AlertClient) error

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

func RegisterAlertHandlerFromEndpoint 

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

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

func RegisterAlertHandlerServer 

func RegisterAlertHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extV1.AlertServer) error

RegisterAlertHandlerServer registers the http handlers for service Alert to "mux". UnaryRPC :call AlertServer 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 RegisterAlertHandlerFromEndpoint instead.

func RegisterDataSourceHandler 

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

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

func RegisterDataSourceHandlerClient 

func RegisterDataSourceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extV1.DataSourceClient) error

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

func RegisterDataSourceHandlerFromEndpoint 

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

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

func RegisterDataSourceHandlerServer 

func RegisterDataSourceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extV1.DataSourceServer) error

RegisterDataSourceHandlerServer registers the http handlers for service DataSource to "mux". UnaryRPC :call DataSourceServer 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 RegisterDataSourceHandlerFromEndpoint instead.

func RegisterEscalationPolicyHandler 

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

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

func RegisterEscalationPolicyHandlerClient 

func RegisterEscalationPolicyHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extV1.EscalationPolicyClient) error

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

func RegisterEscalationPolicyHandlerFromEndpoint 

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

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

func RegisterEscalationPolicyHandlerServer 

func RegisterEscalationPolicyHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extV1.EscalationPolicyServer) error

RegisterEscalationPolicyHandlerServer registers the http handlers for service EscalationPolicy to "mux". UnaryRPC :call EscalationPolicyServer 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 RegisterEscalationPolicyHandlerFromEndpoint instead.

func RegisterEventHandler 

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

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

func RegisterEventHandlerClient 

func RegisterEventHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extV1.EventClient) error

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

func RegisterEventHandlerFromEndpoint 

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

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

func RegisterEventHandlerServer 

func RegisterEventHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extV1.EventServer) error

RegisterEventHandlerServer registers the http handlers for service Event to "mux". UnaryRPC :call EventServer 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 RegisterEventHandlerFromEndpoint instead.

func RegisterEventRuleHandler 

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

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

func RegisterEventRuleHandlerClient 

func RegisterEventRuleHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extV1.EventRuleClient) error

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

func RegisterEventRuleHandlerFromEndpoint 

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

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

func RegisterEventRuleHandlerServer 

func RegisterEventRuleHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extV1.EventRuleServer) error

RegisterEventRuleHandlerServer registers the http handlers for service EventRule to "mux". UnaryRPC :call EventRuleServer 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 RegisterEventRuleHandlerFromEndpoint instead.

func RegisterLogHandler 

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

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

func RegisterLogHandlerClient 

func RegisterLogHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extV1.LogClient) error

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

func RegisterLogHandlerFromEndpoint 

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

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

func RegisterLogHandlerServer 

func RegisterLogHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extV1.LogServer) error

RegisterLogHandlerServer registers the http handlers for service Log to "mux". UnaryRPC :call LogServer 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 RegisterLogHandlerFromEndpoint 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 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 RegisterProjectAlertConfigHandler 

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

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

func RegisterProjectAlertConfigHandlerClient 

func RegisterProjectAlertConfigHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extV1.ProjectAlertConfigClient) error

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

func RegisterProjectAlertConfigHandlerFromEndpoint 

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

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

func RegisterProjectAlertConfigHandlerServer 

func RegisterProjectAlertConfigHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extV1.ProjectAlertConfigServer) error

RegisterProjectAlertConfigHandlerServer registers the http handlers for service ProjectAlertConfig to "mux". UnaryRPC :call ProjectAlertConfigServer 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 RegisterProjectAlertConfigHandlerFromEndpoint instead.

func RegisterWebhookHandler 

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

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

func RegisterWebhookHandlerClient 

func RegisterWebhookHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extV1.WebhookClient) error

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

func RegisterWebhookHandlerFromEndpoint 

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

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

func RegisterWebhookHandlerServer 

func RegisterWebhookHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extV1.WebhookServer) error

RegisterWebhookHandlerServer registers the http handlers for service Webhook to "mux". UnaryRPC :call WebhookServer 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 RegisterWebhookHandlerFromEndpoint 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.