Documentation

Overview

    Package etcdserverpb is a reverse proxy.

    It translates gRPC into RESTful JSON APIs.

    Index

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    func RegisterAuthHandler

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

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

      func RegisterAuthHandlerClient

      func RegisterAuthHandlerClient(ctx context.Context, mux *runtime.ServeMux, client etcdserverpb.AuthClient) error

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

        func RegisterAuthHandlerFromEndpoint

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

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

          func RegisterClusterHandler

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

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

            func RegisterClusterHandlerClient

            func RegisterClusterHandlerClient(ctx context.Context, mux *runtime.ServeMux, client etcdserverpb.ClusterClient) error

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

              func RegisterClusterHandlerFromEndpoint

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

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

                func RegisterKVHandler

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

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

                  func RegisterKVHandlerClient

                  func RegisterKVHandlerClient(ctx context.Context, mux *runtime.ServeMux, client etcdserverpb.KVClient) error

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

                    func RegisterKVHandlerFromEndpoint

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

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

                      func RegisterLeaseHandler

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

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

                        func RegisterLeaseHandlerClient

                        func RegisterLeaseHandlerClient(ctx context.Context, mux *runtime.ServeMux, client etcdserverpb.LeaseClient) error

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

                          func RegisterLeaseHandlerFromEndpoint

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

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

                            func RegisterMaintenanceHandler

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

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

                              func RegisterMaintenanceHandlerClient

                              func RegisterMaintenanceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client etcdserverpb.MaintenanceClient) error

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

                                func RegisterMaintenanceHandlerFromEndpoint

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

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

                                  func RegisterWatchHandler

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

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

                                    func RegisterWatchHandlerClient

                                    func RegisterWatchHandlerClient(ctx context.Context, mux *runtime.ServeMux, client etcdserverpb.WatchClient) error

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

                                      func RegisterWatchHandlerFromEndpoint

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

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

                                        Types

                                        This section is empty.

                                        Source Files