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: 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.

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 RegisterBudgetHandler 

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

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

func RegisterBudgetHandlerClient 

func RegisterBudgetHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extV1.BudgetClient) error

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

func RegisterBudgetHandlerFromEndpoint 

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

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

func RegisterBudgetHandlerServer 

func RegisterBudgetHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extV1.BudgetServer) error

RegisterBudgetHandlerServer registers the http handlers for service Budget to "mux". UnaryRPC :call BudgetServer 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 RegisterBudgetHandlerFromEndpoint instead.

func RegisterBudgetUsageHandler 

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

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

func RegisterBudgetUsageHandlerClient 

func RegisterBudgetUsageHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extV1.BudgetUsageClient) error

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

func RegisterBudgetUsageHandlerFromEndpoint 

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

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

func RegisterBudgetUsageHandlerServer 

func RegisterBudgetUsageHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extV1.BudgetUsageServer) error

RegisterBudgetUsageHandlerServer registers the http handlers for service BudgetUsage to "mux". UnaryRPC :call BudgetUsageServer 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 RegisterBudgetUsageHandlerFromEndpoint instead.

func RegisterCostHandler 

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

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

func RegisterCostHandlerClient 

func RegisterCostHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extV1.CostClient) error

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

func RegisterCostHandlerFromEndpoint 

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

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

func RegisterCostHandlerServer 

func RegisterCostHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extV1.CostServer) error

RegisterCostHandlerServer registers the http handlers for service Cost to "mux". UnaryRPC :call CostServer 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 RegisterCostHandlerFromEndpoint instead.

func RegisterCostQuerySetHandler 

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

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

func RegisterCostQuerySetHandlerClient 

func RegisterCostQuerySetHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extV1.CostQuerySetClient) error

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

func RegisterCostQuerySetHandlerFromEndpoint 

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

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

func RegisterCostQuerySetHandlerServer 

func RegisterCostQuerySetHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extV1.CostQuerySetServer) error

RegisterCostQuerySetHandlerServer registers the http handlers for service CostQuerySet to "mux". UnaryRPC :call CostQuerySetServer 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 RegisterCostQuerySetHandlerFromEndpoint instead.

func RegisterCostReportConfigHandler 

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

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

func RegisterCostReportConfigHandlerClient 

func RegisterCostReportConfigHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extV1.CostReportConfigClient) error

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

func RegisterCostReportConfigHandlerFromEndpoint 

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

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

func RegisterCostReportConfigHandlerServer 

func RegisterCostReportConfigHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extV1.CostReportConfigServer) error

RegisterCostReportConfigHandlerServer registers the http handlers for service CostReportConfig to "mux". UnaryRPC :call CostReportConfigServer 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 RegisterCostReportConfigHandlerFromEndpoint instead.

func RegisterCostReportDataHandler 

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

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

func RegisterCostReportDataHandlerClient 

func RegisterCostReportDataHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extV1.CostReportDataClient) error

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

func RegisterCostReportDataHandlerFromEndpoint 

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

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

func RegisterCostReportDataHandlerServer 

func RegisterCostReportDataHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extV1.CostReportDataServer) error

RegisterCostReportDataHandlerServer registers the http handlers for service CostReportData to "mux". UnaryRPC :call CostReportDataServer 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 RegisterCostReportDataHandlerFromEndpoint instead.

func RegisterCostReportHandler 

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

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

func RegisterCostReportHandlerClient 

func RegisterCostReportHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extV1.CostReportClient) error

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

func RegisterCostReportHandlerFromEndpoint 

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

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

func RegisterCostReportHandlerServer 

func RegisterCostReportHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extV1.CostReportServer) error

RegisterCostReportHandlerServer registers the http handlers for service CostReport to "mux". UnaryRPC :call CostReportServer 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 RegisterCostReportHandlerFromEndpoint instead.

func RegisterDataSourceAccountHandler 

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

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

func RegisterDataSourceAccountHandlerClient 

func RegisterDataSourceAccountHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extV1.DataSourceAccountClient) error

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

func RegisterDataSourceAccountHandlerFromEndpoint 

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

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

func RegisterDataSourceAccountHandlerServer 

func RegisterDataSourceAccountHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extV1.DataSourceAccountServer) error

RegisterDataSourceAccountHandlerServer registers the http handlers for service DataSourceAccount to "mux". UnaryRPC :call DataSourceAccountServer 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 RegisterDataSourceAccountHandlerFromEndpoint 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 RegisterDataSourceRuleHandler 

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

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

func RegisterDataSourceRuleHandlerClient 

func RegisterDataSourceRuleHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extV1.DataSourceRuleClient) error

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

func RegisterDataSourceRuleHandlerFromEndpoint 

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

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

func RegisterDataSourceRuleHandlerServer 

func RegisterDataSourceRuleHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extV1.DataSourceRuleServer) error

RegisterDataSourceRuleHandlerServer registers the http handlers for service DataSourceRule to "mux". UnaryRPC :call DataSourceRuleServer 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 RegisterDataSourceRuleHandlerFromEndpoint 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.

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.