v2

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: 13 Imported by: 0

Documentation

Overview

Package v2 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v2 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v2 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v2 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v2 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v2 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v2 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v2 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v2 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v2 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v2 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v2 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v2 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v2 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v2 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v2 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v2 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v2 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v2 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v2 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v2 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func RegisterAgentHandler 

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

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

func RegisterAgentHandlerClient 

func RegisterAgentHandlerClient(ctx context.Context, mux *runtime.ServeMux, client v2_0.AgentClient) error

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

func RegisterAgentHandlerFromEndpoint 

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

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

func RegisterAgentHandlerServer 

func RegisterAgentHandlerServer(ctx context.Context, mux *runtime.ServeMux, server v2_0.AgentServer) error

RegisterAgentHandlerServer registers the http handlers for service Agent to "mux". UnaryRPC :call AgentServer 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 RegisterAgentHandlerFromEndpoint instead.

func RegisterAppHandler 

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

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

func RegisterAppHandlerClient 

func RegisterAppHandlerClient(ctx context.Context, mux *runtime.ServeMux, client v2_0.AppClient) error

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

func RegisterAppHandlerFromEndpoint 

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

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

func RegisterAppHandlerServer 

func RegisterAppHandlerServer(ctx context.Context, mux *runtime.ServeMux, server v2_0.AppServer) error

RegisterAppHandlerServer registers the http handlers for service App to "mux". UnaryRPC :call AppServer 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 RegisterAppHandlerFromEndpoint 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 v2_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 "v2_0.DomainClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "v2_0.DomainClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "v2_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 v2_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 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 v2_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 "v2_0.EndpointClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "v2_0.EndpointClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "v2_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 v2_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 RegisterExternalAuthHandler 

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

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

func RegisterExternalAuthHandlerClient 

func RegisterExternalAuthHandlerClient(ctx context.Context, mux *runtime.ServeMux, client v2_0.ExternalAuthClient) error

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

func RegisterExternalAuthHandlerFromEndpoint 

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

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

func RegisterExternalAuthHandlerServer 

func RegisterExternalAuthHandlerServer(ctx context.Context, mux *runtime.ServeMux, server v2_0.ExternalAuthServer) error

RegisterExternalAuthHandlerServer registers the http handlers for service ExternalAuth to "mux". UnaryRPC :call ExternalAuthServer 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 RegisterExternalAuthHandlerFromEndpoint 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 v2_0.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 "v2_0.JobClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "v2_0.JobClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "v2_0.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 v2_0.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 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 v2_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 "v2_0.ProjectGroupClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "v2_0.ProjectGroupClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "v2_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 v2_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 v2_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 "v2_0.ProjectClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "v2_0.ProjectClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "v2_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 v2_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 v2_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 "v2_0.ProviderClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "v2_0.ProviderClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "v2_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 v2_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 v2_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 "v2_0.RoleBindingClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "v2_0.RoleBindingClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "v2_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 v2_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 v2_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 "v2_0.RoleClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "v2_0.RoleClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "v2_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 v2_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 RegisterSchemaHandler 

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

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

func RegisterSchemaHandlerClient 

func RegisterSchemaHandlerClient(ctx context.Context, mux *runtime.ServeMux, client v2_0.SchemaClient) error

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

func RegisterSchemaHandlerFromEndpoint 

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

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

func RegisterSchemaHandlerServer 

func RegisterSchemaHandlerServer(ctx context.Context, mux *runtime.ServeMux, server v2_0.SchemaServer) error

RegisterSchemaHandlerServer registers the http handlers for service Schema to "mux". UnaryRPC :call SchemaServer 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 RegisterSchemaHandlerFromEndpoint 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 v2_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 "v2_0.ServiceAccountClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "v2_0.ServiceAccountClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "v2_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 v2_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 RegisterSystemHandler 

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

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

func RegisterSystemHandlerClient 

func RegisterSystemHandlerClient(ctx context.Context, mux *runtime.ServeMux, client v2_0.SystemClient) error

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

func RegisterSystemHandlerFromEndpoint 

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

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

func RegisterSystemHandlerServer 

func RegisterSystemHandlerServer(ctx context.Context, mux *runtime.ServeMux, server v2_0.SystemServer) error

RegisterSystemHandlerServer registers the http handlers for service System to "mux". UnaryRPC :call SystemServer 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 RegisterSystemHandlerFromEndpoint 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 extV2.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 "extV2.TokenClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "extV2.TokenClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "extV2.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 extV2.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 RegisterTrustedAccountHandler 

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

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

func RegisterTrustedAccountHandlerClient 

func RegisterTrustedAccountHandlerClient(ctx context.Context, mux *runtime.ServeMux, client v2_0.TrustedAccountClient) error

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

func RegisterTrustedAccountHandlerFromEndpoint 

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

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

func RegisterTrustedAccountHandlerServer 

func RegisterTrustedAccountHandlerServer(ctx context.Context, mux *runtime.ServeMux, server v2_0.TrustedAccountServer) error

RegisterTrustedAccountHandlerServer registers the http handlers for service TrustedAccount to "mux". UnaryRPC :call TrustedAccountServer 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 RegisterTrustedAccountHandlerFromEndpoint instead.

func RegisterUserGroupHandler 

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

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

func RegisterUserGroupHandlerClient 

func RegisterUserGroupHandlerClient(ctx context.Context, mux *runtime.ServeMux, client v2_0.UserGroupClient) error

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

func RegisterUserGroupHandlerFromEndpoint 

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

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

func RegisterUserGroupHandlerServer 

func RegisterUserGroupHandlerServer(ctx context.Context, mux *runtime.ServeMux, server v2_0.UserGroupServer) error

RegisterUserGroupHandlerServer registers the http handlers for service UserGroup to "mux". UnaryRPC :call UserGroupServer 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 RegisterUserGroupHandlerFromEndpoint 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 v2_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 "v2_0.UserClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "v2_0.UserClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "v2_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 v2_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.

func RegisterUserProfileHandler 

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

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

func RegisterUserProfileHandlerClient 

func RegisterUserProfileHandlerClient(ctx context.Context, mux *runtime.ServeMux, client v2_0.UserProfileClient) error

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

func RegisterUserProfileHandlerFromEndpoint 

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

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

func RegisterUserProfileHandlerServer 

func RegisterUserProfileHandlerServer(ctx context.Context, mux *runtime.ServeMux, server v2_0.UserProfileServer) error

RegisterUserProfileHandlerServer registers the http handlers for service UserProfile to "mux". UnaryRPC :call UserProfileServer 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 RegisterUserProfileHandlerFromEndpoint instead.

func RegisterWorkspaceHandler 

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

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

func RegisterWorkspaceHandlerClient 

func RegisterWorkspaceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client v2_0.WorkspaceClient) error

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

func RegisterWorkspaceHandlerFromEndpoint 

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

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

func RegisterWorkspaceHandlerServer 

func RegisterWorkspaceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server v2_0.WorkspaceServer) error

RegisterWorkspaceHandlerServer registers the http handlers for service Workspace to "mux". UnaryRPC :call WorkspaceServer 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 RegisterWorkspaceHandlerFromEndpoint instead.

func RegisterWorkspaceUserHandler 

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

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

func RegisterWorkspaceUserHandlerClient 

func RegisterWorkspaceUserHandlerClient(ctx context.Context, mux *runtime.ServeMux, client v2_0.WorkspaceUserClient) error

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

func RegisterWorkspaceUserHandlerFromEndpoint 

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

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

func RegisterWorkspaceUserHandlerServer 

func RegisterWorkspaceUserHandlerServer(ctx context.Context, mux *runtime.ServeMux, server v2_0.WorkspaceUserServer) error

RegisterWorkspaceUserHandlerServer registers the http handlers for service WorkspaceUser to "mux". UnaryRPC :call WorkspaceUserServer 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 RegisterWorkspaceUserHandlerFromEndpoint 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.