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

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 RegisterAPIKeyHandler 

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

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

func RegisterAPIKeyHandlerClient 

func RegisterAPIKeyHandlerClient(ctx context.Context, mux *runtime.ServeMux, client v1_0.APIKeyClient) error

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

func RegisterAPIKeyHandlerFromEndpoint 

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

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

func RegisterAPIKeyHandlerServer 

func RegisterAPIKeyHandlerServer(ctx context.Context, mux *runtime.ServeMux, server v1_0.APIKeyServer) error

RegisterAPIKeyHandlerServer registers the http handlers for service APIKey to "mux". UnaryRPC :call APIKeyServer 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 RegisterAPIKeyHandlerFromEndpoint instead.

func RegisterAuthorizationHandler 

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

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

func RegisterAuthorizationHandlerClient 

func RegisterAuthorizationHandlerClient(ctx context.Context, mux *runtime.ServeMux, client v1_0.AuthorizationClient) error

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

func RegisterAuthorizationHandlerFromEndpoint 

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

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

func RegisterAuthorizationHandlerServer 

func RegisterAuthorizationHandlerServer(ctx context.Context, mux *runtime.ServeMux, server v1_0.AuthorizationServer) error

RegisterAuthorizationHandlerServer registers the http handlers for service Authorization to "mux". UnaryRPC :call AuthorizationServer 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 RegisterAuthorizationHandlerFromEndpoint instead.

func RegisterDomainHandler 

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

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

func RegisterDomainHandlerClient 

func RegisterDomainHandlerClient(ctx context.Context, mux *runtime.ServeMux, client v1_0.DomainClient) error

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

func RegisterDomainHandlerFromEndpoint 

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

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

func RegisterDomainHandlerServer 

func RegisterDomainHandlerServer(ctx context.Context, mux *runtime.ServeMux, server v1_0.DomainServer) error

RegisterDomainHandlerServer registers the http handlers for service Domain to "mux". UnaryRPC :call DomainServer 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 RegisterDomainHandlerFromEndpoint instead.

func RegisterDomainOwnerHandler 

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

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

func RegisterDomainOwnerHandlerClient 

func RegisterDomainOwnerHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extV1.DomainOwnerClient) error

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

func RegisterDomainOwnerHandlerFromEndpoint 

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

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

func RegisterDomainOwnerHandlerServer 

func RegisterDomainOwnerHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extV1.DomainOwnerServer) error

RegisterDomainOwnerHandlerServer registers the http handlers for service DomainOwner to "mux". UnaryRPC :call DomainOwnerServer 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 RegisterDomainOwnerHandlerFromEndpoint instead.

func RegisterEndpointHandler 

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

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

func RegisterEndpointHandlerClient 

func RegisterEndpointHandlerClient(ctx context.Context, mux *runtime.ServeMux, client v1_0.EndpointClient) error

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

func RegisterEndpointHandlerFromEndpoint 

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

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

func RegisterEndpointHandlerServer 

func RegisterEndpointHandlerServer(ctx context.Context, mux *runtime.ServeMux, server v1_0.EndpointServer) error

RegisterEndpointHandlerServer registers the http handlers for service Endpoint to "mux". UnaryRPC :call EndpointServer 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 RegisterEndpointHandlerFromEndpoint instead.

func RegisterPolicyHandler 

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

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

func RegisterPolicyHandlerClient 

func RegisterPolicyHandlerClient(ctx context.Context, mux *runtime.ServeMux, client v1_0.PolicyClient) error

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

func RegisterPolicyHandlerFromEndpoint 

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

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

func RegisterPolicyHandlerServer 

func RegisterPolicyHandlerServer(ctx context.Context, mux *runtime.ServeMux, server v1_0.PolicyServer) error

RegisterPolicyHandlerServer registers the http handlers for service Policy to "mux". UnaryRPC :call PolicyServer 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 RegisterPolicyHandlerFromEndpoint instead.

func RegisterProjectGroupHandler 

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

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

func RegisterProjectGroupHandlerClient 

func RegisterProjectGroupHandlerClient(ctx context.Context, mux *runtime.ServeMux, client v1_0.ProjectGroupClient) error

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

func RegisterProjectGroupHandlerFromEndpoint 

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

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

func RegisterProjectGroupHandlerServer 

func RegisterProjectGroupHandlerServer(ctx context.Context, mux *runtime.ServeMux, server v1_0.ProjectGroupServer) error

RegisterProjectGroupHandlerServer registers the http handlers for service ProjectGroup to "mux". UnaryRPC :call ProjectGroupServer 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 RegisterProjectGroupHandlerFromEndpoint instead.

func RegisterProjectHandler 

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

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

func RegisterProjectHandlerClient 

func RegisterProjectHandlerClient(ctx context.Context, mux *runtime.ServeMux, client v1_0.ProjectClient) error

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

func RegisterProjectHandlerFromEndpoint 

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

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

func RegisterProjectHandlerServer 

func RegisterProjectHandlerServer(ctx context.Context, mux *runtime.ServeMux, server v1_0.ProjectServer) error

RegisterProjectHandlerServer registers the http handlers for service Project to "mux". UnaryRPC :call ProjectServer 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 RegisterProjectHandlerFromEndpoint instead.

func RegisterProviderHandler 

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

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

func RegisterProviderHandlerClient 

func RegisterProviderHandlerClient(ctx context.Context, mux *runtime.ServeMux, client v1_0.ProviderClient) error

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

func RegisterProviderHandlerFromEndpoint 

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

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

func RegisterProviderHandlerServer 

func RegisterProviderHandlerServer(ctx context.Context, mux *runtime.ServeMux, server v1_0.ProviderServer) error

RegisterProviderHandlerServer registers the http handlers for service Provider to "mux". UnaryRPC :call ProviderServer 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 RegisterProviderHandlerFromEndpoint instead.

func RegisterRoleBindingHandler 

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

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

func RegisterRoleBindingHandlerClient 

func RegisterRoleBindingHandlerClient(ctx context.Context, mux *runtime.ServeMux, client v1_0.RoleBindingClient) error

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

func RegisterRoleBindingHandlerFromEndpoint 

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

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

func RegisterRoleBindingHandlerServer 

func RegisterRoleBindingHandlerServer(ctx context.Context, mux *runtime.ServeMux, server v1_0.RoleBindingServer) error

RegisterRoleBindingHandlerServer registers the http handlers for service RoleBinding to "mux". UnaryRPC :call RoleBindingServer 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 RegisterRoleBindingHandlerFromEndpoint instead.

func RegisterRoleHandler 

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

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

func RegisterRoleHandlerClient 

func RegisterRoleHandlerClient(ctx context.Context, mux *runtime.ServeMux, client v1_0.RoleClient) error

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

func RegisterRoleHandlerFromEndpoint 

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

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

func RegisterRoleHandlerServer 

func RegisterRoleHandlerServer(ctx context.Context, mux *runtime.ServeMux, server v1_0.RoleServer) error

RegisterRoleHandlerServer registers the http handlers for service Role to "mux". UnaryRPC :call RoleServer 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 RegisterRoleHandlerFromEndpoint instead.

func RegisterServiceAccountHandler 

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

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

func RegisterServiceAccountHandlerClient 

func RegisterServiceAccountHandlerClient(ctx context.Context, mux *runtime.ServeMux, client v1_0.ServiceAccountClient) error

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

func RegisterServiceAccountHandlerFromEndpoint 

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

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

func RegisterServiceAccountHandlerServer 

func RegisterServiceAccountHandlerServer(ctx context.Context, mux *runtime.ServeMux, server v1_0.ServiceAccountServer) error

RegisterServiceAccountHandlerServer registers the http handlers for service ServiceAccount to "mux". UnaryRPC :call ServiceAccountServer 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 RegisterServiceAccountHandlerFromEndpoint instead.

func RegisterTokenHandler 

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

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

func RegisterTokenHandlerClient 

func RegisterTokenHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extV1.TokenClient) error

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

func RegisterTokenHandlerFromEndpoint 

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

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

func RegisterTokenHandlerServer 

func RegisterTokenHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extV1.TokenServer) error

RegisterTokenHandlerServer registers the http handlers for service Token to "mux". UnaryRPC :call TokenServer 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 RegisterTokenHandlerFromEndpoint instead.

func RegisterUserHandler 

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

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

func RegisterUserHandlerClient 

func RegisterUserHandlerClient(ctx context.Context, mux *runtime.ServeMux, client v1_0.UserClient) error

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

func RegisterUserHandlerFromEndpoint 

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

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

func RegisterUserHandlerServer 

func RegisterUserHandlerServer(ctx context.Context, mux *runtime.ServeMux, server v1_0.UserServer) error

RegisterUserHandlerServer registers the http handlers for service User to "mux". UnaryRPC :call UserServer 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 RegisterUserHandlerFromEndpoint 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.