From 78a5eb79b510eb497deddd1a76f5153bc4b202d2 Mon Sep 17 00:00:00 2001 From: Anthony Romano Date: Mon, 10 Apr 2017 13:45:56 -0700 Subject: [PATCH 1/3] *: add swagger and grpc-gateway assets for v3lock and v3election --- .../dev-guide/api_concurrency_reference_v3.md | 168 +++++++++ .../apispec/swagger/v3election.swagger.json | 334 ++++++++++++++++++ .../apispec/swagger/v3lock.swagger.json | 146 ++++++++ Documentation/docs.md | 3 +- auth/authpb/auth.pb.go | 2 +- .../v3electionpb/v3election.pb.gw.go | 298 ++++++++++++++++ etcdserver/api/v3lock/v3lockpb/v3lock.pb.go | 2 +- .../api/v3lock/v3lockpb/v3lock.pb.gw.go | 155 ++++++++ etcdserver/etcdserverpb/etcdserver.pb.go | 2 +- etcdserver/etcdserverpb/raft_internal.pb.go | 2 +- etcdserver/etcdserverpb/rpc.pb.go | 2 +- lease/leasepb/lease.pb.go | 2 +- mvcc/mvccpb/kv.pb.go | 2 +- raft/raftpb/raft.pb.go | 2 +- scripts/genproto.sh | 32 +- snap/snappb/snap.pb.go | 2 +- wal/walpb/record.pb.go | 2 +- 17 files changed, 1131 insertions(+), 25 deletions(-) create mode 100644 Documentation/dev-guide/api_concurrency_reference_v3.md create mode 100644 Documentation/dev-guide/apispec/swagger/v3election.swagger.json create mode 100644 Documentation/dev-guide/apispec/swagger/v3lock.swagger.json create mode 100644 etcdserver/api/v3election/v3electionpb/v3election.pb.gw.go create mode 100644 etcdserver/api/v3lock/v3lockpb/v3lock.pb.gw.go diff --git a/Documentation/dev-guide/api_concurrency_reference_v3.md b/Documentation/dev-guide/api_concurrency_reference_v3.md new file mode 100644 index 000000000..cf534f4b6 --- /dev/null +++ b/Documentation/dev-guide/api_concurrency_reference_v3.md @@ -0,0 +1,168 @@ +### etcd concurrency API Reference + + +This is a generated documentation. Please read the proto files for more. + + +##### service `Lock` (etcdserver/api/v3lock/v3lockpb/v3lock.proto) + +for grpc-gateway The lock service exposes client-side locking facilities as a gRPC interface. + +| Method | Request Type | Response Type | Description | +| ------ | ------------ | ------------- | ----------- | +| Lock | LockRequest | LockResponse | Lock acquires a distributed shared lock on a given named lock. On success, it will return a unique key that exists so long as the lock is held by the caller. This key can be used in conjunction with transactions to safely ensure updates to etcd only occur while holding lock ownership. The lock is held until Unlock is called on the key or the lease associate with the owner expires. | +| Unlock | UnlockRequest | UnlockResponse | Unlock takes a key returned by Lock and releases the hold on lock. The next Lock caller waiting for the lock will then be woken up and given ownership of the lock. | + + + +##### message `LockRequest` (etcdserver/api/v3lock/v3lockpb/v3lock.proto) + +| Field | Description | Type | +| ----- | ----------- | ---- | +| name | name is the identifier for the distributed shared lock to be acquired. | bytes | +| lease | lease is the ID of the lease that will be attached to ownership of the lock. If the lease expires or is revoked and currently holds the lock, the lock is automatically released. Calls to Lock with the same lease will be treated as a single acquistion; locking twice with the same lease is a no-op. | int64 | + + + +##### message `LockResponse` (etcdserver/api/v3lock/v3lockpb/v3lock.proto) + +| Field | Description | Type | +| ----- | ----------- | ---- | +| header | | etcdserverpb.ResponseHeader | +| key | key is a key that will exist on etcd for the duration that the Lock caller owns the lock. Users should not modify this key or the lock may exhibit undefined behavior. | bytes | + + + +##### message `UnlockRequest` (etcdserver/api/v3lock/v3lockpb/v3lock.proto) + +| Field | Description | Type | +| ----- | ----------- | ---- | +| key | key is the lock ownership key granted by Lock. | bytes | + + + +##### message `UnlockResponse` (etcdserver/api/v3lock/v3lockpb/v3lock.proto) + +| Field | Description | Type | +| ----- | ----------- | ---- | +| header | | etcdserverpb.ResponseHeader | + + + +##### service `Election` (etcdserver/api/v3election/v3electionpb/v3election.proto) + +for grpc-gateway The election service exposes client-side election facilities as a gRPC interface. + +| Method | Request Type | Response Type | Description | +| ------ | ------------ | ------------- | ----------- | +| Campaign | CampaignRequest | CampaignResponse | Campaign waits to acquire leadership in an election, returning a LeaderKey representing the leadership if successful. The LeaderKey can then be used to issue new values on the election, transactionally guard API requests on leadership still being held, and resign from the election. | +| Proclaim | ProclaimRequest | ProclaimResponse | Proclaim updates the leader's posted value with a new value. | +| Leader | LeaderRequest | LeaderResponse | Leader returns the current election proclamation, if any. | +| Observe | LeaderRequest | LeaderResponse | Observe streams election proclamations in-order as made by the election's elected leaders. | +| Resign | ResignRequest | ResignResponse | Resign releases election leadership so other campaigners may acquire leadership on the election. | + + + +##### message `CampaignRequest` (etcdserver/api/v3election/v3electionpb/v3election.proto) + +| Field | Description | Type | +| ----- | ----------- | ---- | +| name | name is the election's identifier for the campaign. | bytes | +| lease | lease is the ID of the lease attached to leadership of the election. If the lease expires or is revoked before resigning leadership, then the leadership is transferred to the next campaigner, if any. | int64 | +| value | value is the initial proclaimed value set when the campaigner wins the election. | bytes | + + + +##### message `CampaignResponse` (etcdserver/api/v3election/v3electionpb/v3election.proto) + +| Field | Description | Type | +| ----- | ----------- | ---- | +| header | | etcdserverpb.ResponseHeader | +| leader | leader describes the resources used for holding leadereship of the election. | LeaderKey | + + + +##### message `LeaderKey` (etcdserver/api/v3election/v3electionpb/v3election.proto) + +| Field | Description | Type | +| ----- | ----------- | ---- | +| name | name is the election identifier that correponds to the leadership key. | bytes | +| key | key is an opaque key representing the ownership of the election. If the key is deleted, then leadership is lost. | bytes | +| rev | rev is the creation revision of the key. It can be used to test for ownership of an election during transactions by testing the key's creation revision matches rev. | int64 | +| lease | lease is the lease ID of the election leader. | int64 | + + + +##### message `LeaderRequest` (etcdserver/api/v3election/v3electionpb/v3election.proto) + +| Field | Description | Type | +| ----- | ----------- | ---- | +| name | name is the election identifier for the leadership information. | bytes | + + + +##### message `LeaderResponse` (etcdserver/api/v3election/v3electionpb/v3election.proto) + +| Field | Description | Type | +| ----- | ----------- | ---- | +| header | | etcdserverpb.ResponseHeader | +| kv | kv is the key-value pair representing the latest leader update. | mvccpb.KeyValue | + + + +##### message `ProclaimRequest` (etcdserver/api/v3election/v3electionpb/v3election.proto) + +| Field | Description | Type | +| ----- | ----------- | ---- | +| leader | leader is the leadership hold on the election. | LeaderKey | +| value | value is an update meant to overwrite the leader's current value. | bytes | + + + +##### message `ProclaimResponse` (etcdserver/api/v3election/v3electionpb/v3election.proto) + +| Field | Description | Type | +| ----- | ----------- | ---- | +| header | | etcdserverpb.ResponseHeader | + + + +##### message `ResignRequest` (etcdserver/api/v3election/v3electionpb/v3election.proto) + +| Field | Description | Type | +| ----- | ----------- | ---- | +| leader | leader is the leadership to relinquish by resignation. | LeaderKey | + + + +##### message `ResignResponse` (etcdserver/api/v3election/v3electionpb/v3election.proto) + +| Field | Description | Type | +| ----- | ----------- | ---- | +| header | | etcdserverpb.ResponseHeader | + + + +##### message `Event` (mvcc/mvccpb/kv.proto) + +| Field | Description | Type | +| ----- | ----------- | ---- | +| type | type is the kind of event. If type is a PUT, it indicates new data has been stored to the key. If type is a DELETE, it indicates the key was deleted. | EventType | +| kv | kv holds the KeyValue for the event. A PUT event contains current kv pair. A PUT event with kv.Version=1 indicates the creation of a key. A DELETE/EXPIRE event contains the deleted key with its modification revision set to the revision of deletion. | KeyValue | +| prev_kv | prev_kv holds the key-value pair before the event happens. | KeyValue | + + + +##### message `KeyValue` (mvcc/mvccpb/kv.proto) + +| Field | Description | Type | +| ----- | ----------- | ---- | +| key | key is the key in bytes. An empty key is not allowed. | bytes | +| create_revision | create_revision is the revision of last creation on this key. | int64 | +| mod_revision | mod_revision is the revision of last modification on this key. | int64 | +| version | version is the version of the key. A deletion resets the version to zero and any modification of the key increases its version. | int64 | +| value | value is the value held by the key, in bytes. | bytes | +| lease | lease is the ID of the lease that attached to key. When the attached lease expires, the key will be deleted. If lease is 0, then no lease is attached to the key. | int64 | + + + diff --git a/Documentation/dev-guide/apispec/swagger/v3election.swagger.json b/Documentation/dev-guide/apispec/swagger/v3election.swagger.json new file mode 100644 index 000000000..fa9a6bbc4 --- /dev/null +++ b/Documentation/dev-guide/apispec/swagger/v3election.swagger.json @@ -0,0 +1,334 @@ +{ + "swagger": "2.0", + "info": { + "title": "etcdserver/api/v3election/v3electionpb/v3election.proto", + "version": "version not set" + }, + "schemes": [ + "http", + "https" + ], + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": { + "/v3alpha/election/campaign": { + "post": { + "summary": "Campaign waits to acquire leadership in an election, returning a LeaderKey\nrepresenting the leadership if successful. The LeaderKey can then be used\nto issue new values on the election, transactionally guard API requests on\nleadership still being held, and resign from the election.", + "operationId": "Campaign", + "responses": { + "200": { + "description": "", + "schema": { + "$ref": "#/definitions/v3electionpbCampaignResponse" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v3electionpbCampaignRequest" + } + } + ], + "tags": [ + "Election" + ] + } + }, + "/v3alpha/election/leader": { + "post": { + "summary": "Leader returns the current election proclamation, if any.", + "operationId": "Leader", + "responses": { + "200": { + "description": "", + "schema": { + "$ref": "#/definitions/v3electionpbLeaderResponse" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v3electionpbLeaderRequest" + } + } + ], + "tags": [ + "Election" + ] + } + }, + "/v3alpha/election/observe": { + "post": { + "summary": "Observe streams election proclamations in-order as made by the election's\nelected leaders.", + "operationId": "Observe", + "responses": { + "200": { + "description": "(streaming responses)", + "schema": { + "$ref": "#/definitions/v3electionpbLeaderResponse" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v3electionpbLeaderRequest" + } + } + ], + "tags": [ + "Election" + ] + } + }, + "/v3alpha/election/proclaim": { + "post": { + "summary": "Proclaim updates the leader's posted value with a new value.", + "operationId": "Proclaim", + "responses": { + "200": { + "description": "", + "schema": { + "$ref": "#/definitions/v3electionpbProclaimResponse" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v3electionpbProclaimRequest" + } + } + ], + "tags": [ + "Election" + ] + } + }, + "/v3alpha/election/resign": { + "post": { + "summary": "Resign releases election leadership so other campaigners may acquire\nleadership on the election.", + "operationId": "Resign", + "responses": { + "200": { + "description": "", + "schema": { + "$ref": "#/definitions/v3electionpbResignResponse" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v3electionpbResignRequest" + } + } + ], + "tags": [ + "Election" + ] + } + } + }, + "definitions": { + "etcdserverpbResponseHeader": { + "type": "object", + "properties": { + "cluster_id": { + "type": "string", + "format": "uint64", + "description": "cluster_id is the ID of the cluster which sent the response." + }, + "member_id": { + "type": "string", + "format": "uint64", + "description": "member_id is the ID of the member which sent the response." + }, + "revision": { + "type": "string", + "format": "int64", + "description": "revision is the key-value store revision when the request was applied." + }, + "raft_term": { + "type": "string", + "format": "uint64", + "description": "raft_term is the raft term when the request was applied." + } + } + }, + "mvccpbKeyValue": { + "type": "object", + "properties": { + "key": { + "type": "string", + "format": "byte", + "description": "key is the key in bytes. An empty key is not allowed." + }, + "create_revision": { + "type": "string", + "format": "int64", + "description": "create_revision is the revision of last creation on this key." + }, + "mod_revision": { + "type": "string", + "format": "int64", + "description": "mod_revision is the revision of last modification on this key." + }, + "version": { + "type": "string", + "format": "int64", + "description": "version is the version of the key. A deletion resets\nthe version to zero and any modification of the key\nincreases its version." + }, + "value": { + "type": "string", + "format": "byte", + "description": "value is the value held by the key, in bytes." + }, + "lease": { + "type": "string", + "format": "int64", + "description": "lease is the ID of the lease that attached to key.\nWhen the attached lease expires, the key will be deleted.\nIf lease is 0, then no lease is attached to the key." + } + } + }, + "v3electionpbCampaignRequest": { + "type": "object", + "properties": { + "name": { + "type": "string", + "format": "byte", + "description": "name is the election's identifier for the campaign." + }, + "lease": { + "type": "string", + "format": "int64", + "description": "lease is the ID of the lease attached to leadership of the election. If the\nlease expires or is revoked before resigning leadership, then the\nleadership is transferred to the next campaigner, if any." + }, + "value": { + "type": "string", + "format": "byte", + "description": "value is the initial proclaimed value set when the campaigner wins the\nelection." + } + } + }, + "v3electionpbCampaignResponse": { + "type": "object", + "properties": { + "header": { + "$ref": "#/definitions/etcdserverpbResponseHeader" + }, + "leader": { + "$ref": "#/definitions/v3electionpbLeaderKey", + "description": "leader describes the resources used for holding leadereship of the election." + } + } + }, + "v3electionpbLeaderKey": { + "type": "object", + "properties": { + "name": { + "type": "string", + "format": "byte", + "description": "name is the election identifier that correponds to the leadership key." + }, + "key": { + "type": "string", + "format": "byte", + "description": "key is an opaque key representing the ownership of the election. If the key\nis deleted, then leadership is lost." + }, + "rev": { + "type": "string", + "format": "int64", + "description": "rev is the creation revision of the key. It can be used to test for ownership\nof an election during transactions by testing the key's creation revision\nmatches rev." + }, + "lease": { + "type": "string", + "format": "int64", + "description": "lease is the lease ID of the election leader." + } + } + }, + "v3electionpbLeaderRequest": { + "type": "object", + "properties": { + "name": { + "type": "string", + "format": "byte", + "description": "name is the election identifier for the leadership information." + } + } + }, + "v3electionpbLeaderResponse": { + "type": "object", + "properties": { + "header": { + "$ref": "#/definitions/etcdserverpbResponseHeader" + }, + "kv": { + "$ref": "#/definitions/mvccpbKeyValue", + "description": "kv is the key-value pair representing the latest leader update." + } + } + }, + "v3electionpbProclaimRequest": { + "type": "object", + "properties": { + "leader": { + "$ref": "#/definitions/v3electionpbLeaderKey", + "description": "leader is the leadership hold on the election." + }, + "value": { + "type": "string", + "format": "byte", + "description": "value is an update meant to overwrite the leader's current value." + } + } + }, + "v3electionpbProclaimResponse": { + "type": "object", + "properties": { + "header": { + "$ref": "#/definitions/etcdserverpbResponseHeader" + } + } + }, + "v3electionpbResignRequest": { + "type": "object", + "properties": { + "leader": { + "$ref": "#/definitions/v3electionpbLeaderKey", + "description": "leader is the leadership to relinquish by resignation." + } + } + }, + "v3electionpbResignResponse": { + "type": "object", + "properties": { + "header": { + "$ref": "#/definitions/etcdserverpbResponseHeader" + } + } + } + } +} diff --git a/Documentation/dev-guide/apispec/swagger/v3lock.swagger.json b/Documentation/dev-guide/apispec/swagger/v3lock.swagger.json new file mode 100644 index 000000000..29cec570a --- /dev/null +++ b/Documentation/dev-guide/apispec/swagger/v3lock.swagger.json @@ -0,0 +1,146 @@ +{ + "swagger": "2.0", + "info": { + "title": "etcdserver/api/v3lock/v3lockpb/v3lock.proto", + "version": "version not set" + }, + "schemes": [ + "http", + "https" + ], + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": { + "/v3alpha/lock/lock": { + "post": { + "summary": "Lock acquires a distributed shared lock on a given named lock.\nOn success, it will return a unique key that exists so long as the\nlock is held by the caller. This key can be used in conjunction with\ntransactions to safely ensure updates to etcd only occur while holding\nlock ownership. The lock is held until Unlock is called on the key or the\nlease associate with the owner expires.", + "operationId": "Lock", + "responses": { + "200": { + "description": "", + "schema": { + "$ref": "#/definitions/v3lockpbLockResponse" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v3lockpbLockRequest" + } + } + ], + "tags": [ + "Lock" + ] + } + }, + "/v3alpha/lock/unlock": { + "post": { + "summary": "Unlock takes a key returned by Lock and releases the hold on lock. The\nnext Lock caller waiting for the lock will then be woken up and given\nownership of the lock.", + "operationId": "Unlock", + "responses": { + "200": { + "description": "", + "schema": { + "$ref": "#/definitions/v3lockpbUnlockResponse" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v3lockpbUnlockRequest" + } + } + ], + "tags": [ + "Lock" + ] + } + } + }, + "definitions": { + "etcdserverpbResponseHeader": { + "type": "object", + "properties": { + "cluster_id": { + "type": "string", + "format": "uint64", + "description": "cluster_id is the ID of the cluster which sent the response." + }, + "member_id": { + "type": "string", + "format": "uint64", + "description": "member_id is the ID of the member which sent the response." + }, + "revision": { + "type": "string", + "format": "int64", + "description": "revision is the key-value store revision when the request was applied." + }, + "raft_term": { + "type": "string", + "format": "uint64", + "description": "raft_term is the raft term when the request was applied." + } + } + }, + "v3lockpbLockRequest": { + "type": "object", + "properties": { + "name": { + "type": "string", + "format": "byte", + "description": "name is the identifier for the distributed shared lock to be acquired." + }, + "lease": { + "type": "string", + "format": "int64", + "description": "lease is the ID of the lease that will be attached to ownership of the\nlock. If the lease expires or is revoked and currently holds the lock,\nthe lock is automatically released. Calls to Lock with the same lease will\nbe treated as a single acquistion; locking twice with the same lease is a\nno-op." + } + } + }, + "v3lockpbLockResponse": { + "type": "object", + "properties": { + "header": { + "$ref": "#/definitions/etcdserverpbResponseHeader" + }, + "key": { + "type": "string", + "format": "byte", + "description": "key is a key that will exist on etcd for the duration that the Lock caller\nowns the lock. Users should not modify this key or the lock may exhibit\nundefined behavior." + } + } + }, + "v3lockpbUnlockRequest": { + "type": "object", + "properties": { + "key": { + "type": "string", + "format": "byte", + "description": "key is the lock ownership key granted by Lock." + } + } + }, + "v3lockpbUnlockResponse": { + "type": "object", + "properties": { + "header": { + "$ref": "#/definitions/etcdserverpbResponseHeader" + } + } + } + } +} diff --git a/Documentation/docs.md b/Documentation/docs.md index 505f719b0..0a7bc25e0 100644 --- a/Documentation/docs.md +++ b/Documentation/docs.md @@ -12,7 +12,7 @@ The easiest way to get started using etcd as a distributed key-value store is to - [Setting up local clusters][local_cluster] - [Interacting with etcd][interacting] - - [gRPC API references][api_ref] + - gRPC [etcd core][api_ref] and [etcd concurrency][api_concurrency_ref] API references - [HTTP JSON API through the gRPC gateway][api_grpc_gateway] - [gRPC naming and discovery][grpc_naming] - [Client][namespace_client] and [proxy][namespace_proxy] namespacing @@ -62,6 +62,7 @@ To learn more about the concepts and internals behind etcd, read the following p Answers to [common questions] about etcd. [api_ref]: dev-guide/api_reference_v3.md +[api_concurrency_ref]: dev-guide/api_concurrency_reference_v3.md [api_grpc_gateway]: dev-guide/api_grpc_gateway.md [clustering]: op-guide/clustering.md [conf]: op-guide/configuration.md diff --git a/auth/authpb/auth.pb.go b/auth/authpb/auth.pb.go index c6e2a12a7..009ebda70 100644 --- a/auth/authpb/auth.pb.go +++ b/auth/authpb/auth.pb.go @@ -803,7 +803,7 @@ func init() { proto.RegisterFile("auth.proto", fileDescriptorAuth) } var fileDescriptorAuth = []byte{ // 288 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x6c, 0x90, 0xc1, 0x4a, 0xc3, 0x30, + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0xc1, 0x4a, 0xc3, 0x30, 0x1c, 0xc6, 0x9b, 0xb6, 0x1b, 0xed, 0x5f, 0x27, 0x25, 0x0c, 0x0c, 0x13, 0x42, 0xe9, 0xa9, 0x78, 0xa8, 0xb0, 0x5d, 0xbc, 0x2a, 0xf6, 0x20, 0x78, 0x90, 0x50, 0xf1, 0x28, 0x1d, 0x0d, 0x75, 0x6c, 0x6d, 0x4a, 0x32, 0x91, 0xbe, 0x89, 0x07, 0x1f, 0x68, 0xc7, 0x3d, 0x82, 0xab, 0x2f, 0x22, 0x4d, diff --git a/etcdserver/api/v3election/v3electionpb/v3election.pb.gw.go b/etcdserver/api/v3election/v3electionpb/v3election.pb.gw.go new file mode 100644 index 000000000..8f0bb9d69 --- /dev/null +++ b/etcdserver/api/v3election/v3electionpb/v3election.pb.gw.go @@ -0,0 +1,298 @@ +// Code generated by protoc-gen-grpc-gateway +// source: etcdserver/api/v3election/v3electionpb/v3election.proto +// DO NOT EDIT! + +/* +Package v3electionpb is a reverse proxy. + +It translates gRPC into RESTful JSON APIs. +*/ +package v3electionpb + +import ( + "io" + "net/http" + + "github.com/golang/protobuf/proto" + "github.com/grpc-ecosystem/grpc-gateway/runtime" + "github.com/grpc-ecosystem/grpc-gateway/utilities" + "golang.org/x/net/context" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/grpclog" +) + +var _ codes.Code +var _ io.Reader +var _ = runtime.String +var _ = utilities.NewDoubleArray + +func request_Election_Campaign_0(ctx context.Context, marshaler runtime.Marshaler, client ElectionClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq CampaignRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.Campaign(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func request_Election_Proclaim_0(ctx context.Context, marshaler runtime.Marshaler, client ElectionClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq ProclaimRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.Proclaim(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func request_Election_Leader_0(ctx context.Context, marshaler runtime.Marshaler, client ElectionClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq LeaderRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.Leader(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func request_Election_Observe_0(ctx context.Context, marshaler runtime.Marshaler, client ElectionClient, req *http.Request, pathParams map[string]string) (Election_ObserveClient, runtime.ServerMetadata, error) { + var protoReq LeaderRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + stream, err := client.Observe(ctx, &protoReq) + if err != nil { + return nil, metadata, err + } + header, err := stream.Header() + if err != nil { + return nil, metadata, err + } + metadata.HeaderMD = header + return stream, metadata, nil + +} + +func request_Election_Resign_0(ctx context.Context, marshaler runtime.Marshaler, client ElectionClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq ResignRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.Resign(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +// RegisterElectionHandlerFromEndpoint is same as RegisterElectionHandler but +// automatically dials to "endpoint" and closes the connection when "ctx" gets done. +func RegisterElectionHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { + conn, err := grpc.Dial(endpoint, opts...) + if err != nil { + return err + } + defer func() { + if err != nil { + if cerr := conn.Close(); cerr != nil { + grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) + } + return + } + go func() { + <-ctx.Done() + if cerr := conn.Close(); cerr != nil { + grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) + } + }() + }() + + return RegisterElectionHandler(ctx, mux, conn) +} + +// RegisterElectionHandler registers the http handlers for service Election to "mux". +// The handlers forward requests to the grpc endpoint over "conn". +func RegisterElectionHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { + client := NewElectionClient(conn) + + mux.Handle("POST", pattern_Election_Campaign_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_Election_Campaign_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_Election_Campaign_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_Election_Proclaim_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_Election_Proclaim_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_Election_Proclaim_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_Election_Leader_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_Election_Leader_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_Election_Leader_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_Election_Observe_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_Election_Observe_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_Election_Observe_0(ctx, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_Election_Resign_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_Election_Resign_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_Election_Resign_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +var ( + pattern_Election_Campaign_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "election", "campaign"}, "")) + + pattern_Election_Proclaim_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "election", "proclaim"}, "")) + + pattern_Election_Leader_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "election", "leader"}, "")) + + pattern_Election_Observe_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "election", "observe"}, "")) + + pattern_Election_Resign_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "election", "resign"}, "")) +) + +var ( + forward_Election_Campaign_0 = runtime.ForwardResponseMessage + + forward_Election_Proclaim_0 = runtime.ForwardResponseMessage + + forward_Election_Leader_0 = runtime.ForwardResponseMessage + + forward_Election_Observe_0 = runtime.ForwardResponseStream + + forward_Election_Resign_0 = runtime.ForwardResponseMessage +) diff --git a/etcdserver/api/v3lock/v3lockpb/v3lock.pb.go b/etcdserver/api/v3lock/v3lockpb/v3lock.pb.go index 2c6b765c0..44bde286b 100644 --- a/etcdserver/api/v3lock/v3lockpb/v3lock.pb.go +++ b/etcdserver/api/v3lock/v3lockpb/v3lock.pb.go @@ -924,7 +924,7 @@ func init() { proto.RegisterFile("v3lock.proto", fileDescriptorV3Lock) } var fileDescriptorV3Lock = []byte{ // 336 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0xe2, 0x29, 0x33, 0xce, 0xc9, + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x29, 0x33, 0xce, 0xc9, 0x4f, 0xce, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x80, 0xf0, 0x0a, 0x92, 0xa4, 0x44, 0xd2, 0xf3, 0xd3, 0xf3, 0xc1, 0x82, 0xfa, 0x20, 0x16, 0x44, 0x5e, 0x4a, 0x2d, 0xb5, 0x24, 0x39, 0x45, 0x1f, 0x44, 0x14, 0xa7, 0x16, 0x95, 0xa5, 0x16, 0x21, 0x31, 0x0b, 0x92, 0xf4, 0x8b, 0x0a, diff --git a/etcdserver/api/v3lock/v3lockpb/v3lock.pb.gw.go b/etcdserver/api/v3lock/v3lockpb/v3lock.pb.gw.go new file mode 100644 index 000000000..ca506902b --- /dev/null +++ b/etcdserver/api/v3lock/v3lockpb/v3lock.pb.gw.go @@ -0,0 +1,155 @@ +// Code generated by protoc-gen-grpc-gateway +// source: etcdserver/api/v3lock/v3lockpb/v3lock.proto +// DO NOT EDIT! + +/* +Package v3lockpb is a reverse proxy. + +It translates gRPC into RESTful JSON APIs. +*/ +package v3lockpb + +import ( + "io" + "net/http" + + "github.com/golang/protobuf/proto" + "github.com/grpc-ecosystem/grpc-gateway/runtime" + "github.com/grpc-ecosystem/grpc-gateway/utilities" + "golang.org/x/net/context" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/grpclog" +) + +var _ codes.Code +var _ io.Reader +var _ = runtime.String +var _ = utilities.NewDoubleArray + +func request_Lock_Lock_0(ctx context.Context, marshaler runtime.Marshaler, client LockClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq LockRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.Lock(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func request_Lock_Unlock_0(ctx context.Context, marshaler runtime.Marshaler, client LockClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq UnlockRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { + return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.Unlock(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +// RegisterLockHandlerFromEndpoint is same as RegisterLockHandler but +// automatically dials to "endpoint" and closes the connection when "ctx" gets done. +func RegisterLockHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { + conn, err := grpc.Dial(endpoint, opts...) + if err != nil { + return err + } + defer func() { + if err != nil { + if cerr := conn.Close(); cerr != nil { + grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) + } + return + } + go func() { + <-ctx.Done() + if cerr := conn.Close(); cerr != nil { + grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) + } + }() + }() + + return RegisterLockHandler(ctx, mux, conn) +} + +// RegisterLockHandler registers the http handlers for service Lock to "mux". +// The handlers forward requests to the grpc endpoint over "conn". +func RegisterLockHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { + client := NewLockClient(conn) + + mux.Handle("POST", pattern_Lock_Lock_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_Lock_Lock_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_Lock_Lock_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_Lock_Unlock_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, req) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + } + resp, md, err := request_Lock_Unlock_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, outboundMarshaler, w, req, err) + return + } + + forward_Lock_Unlock_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +var ( + pattern_Lock_Lock_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 1}, []string{"v3alpha", "lock"}, "")) + + pattern_Lock_Unlock_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3alpha", "lock", "unlock"}, "")) +) + +var ( + forward_Lock_Lock_0 = runtime.ForwardResponseMessage + + forward_Lock_Unlock_0 = runtime.ForwardResponseMessage +) diff --git a/etcdserver/etcdserverpb/etcdserver.pb.go b/etcdserver/etcdserverpb/etcdserver.pb.go index f34bedf3e..aabf90061 100644 --- a/etcdserver/etcdserverpb/etcdserver.pb.go +++ b/etcdserver/etcdserverpb/etcdserver.pb.go @@ -1018,7 +1018,7 @@ func init() { proto.RegisterFile("etcdserver.proto", fileDescriptorEtcdserver) } var fileDescriptorEtcdserver = []byte{ // 380 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x5c, 0xd2, 0xdd, 0x6e, 0xda, 0x30, + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x5c, 0xd2, 0xdd, 0x6e, 0xda, 0x30, 0x14, 0x07, 0x70, 0x0c, 0xe1, 0xcb, 0x63, 0x1b, 0xb3, 0xd0, 0x74, 0x84, 0xa6, 0x2c, 0x42, 0xbb, 0xc8, 0xd5, 0xf6, 0x0e, 0x2c, 0x5c, 0x44, 0x2a, 0x15, 0x0d, 0x15, 0xbd, 0x76, 0xc9, 0x29, 0x58, 0x02, 0x4c, 0x1d, 0x07, 0xf1, 0x06, 0x7d, 0x85, 0x3e, 0x12, 0x97, 0x7d, 0x82, 0xaa, 0xa5, 0x2f, diff --git a/etcdserver/etcdserverpb/raft_internal.pb.go b/etcdserver/etcdserverpb/raft_internal.pb.go index 66890c93c..44a3b6f69 100644 --- a/etcdserver/etcdserverpb/raft_internal.pb.go +++ b/etcdserver/etcdserverpb/raft_internal.pb.go @@ -2038,7 +2038,7 @@ func init() { proto.RegisterFile("raft_internal.proto", fileDescriptorRaftIntern var fileDescriptorRaftInternal = []byte{ // 837 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x7c, 0x96, 0xdd, 0x52, 0xd3, 0x40, + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x96, 0xdd, 0x52, 0xd3, 0x40, 0x14, 0xc7, 0x69, 0xf9, 0xec, 0xb6, 0x54, 0x5c, 0x40, 0xd7, 0x32, 0x53, 0xa1, 0x8c, 0x8a, 0x5f, 0xe8, 0x94, 0x07, 0xd0, 0x4a, 0x19, 0x60, 0x86, 0x61, 0x98, 0x0c, 0xce, 0x38, 0xe3, 0x45, 0x5c, 0x9a, 0x43, 0x1b, 0x49, 0x93, 0xb8, 0xd9, 0x56, 0x7c, 0x13, 0x1f, 0xc3, 0xaf, 0x87, 0xe0, 0xc2, diff --git a/etcdserver/etcdserverpb/rpc.pb.go b/etcdserver/etcdserverpb/rpc.pb.go index 63429a2e0..74e067d23 100644 --- a/etcdserver/etcdserverpb/rpc.pb.go +++ b/etcdserver/etcdserverpb/rpc.pb.go @@ -16115,7 +16115,7 @@ func init() { proto.RegisterFile("rpc.proto", fileDescriptorRpc) } var fileDescriptorRpc = []byte{ // 3431 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xb4, 0x5b, 0xcd, 0x73, 0x1b, 0xc7, + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x5b, 0xcd, 0x73, 0x1b, 0xc7, 0xb1, 0xe7, 0x02, 0x04, 0x40, 0x34, 0x3e, 0x08, 0x0d, 0x29, 0x09, 0x84, 0x24, 0x8a, 0x1a, 0x7d, 0x51, 0x92, 0x4d, 0xda, 0xb4, 0xdf, 0x3b, 0xe8, 0xb9, 0x5c, 0x8f, 0x22, 0x61, 0x91, 0x8f, 0x14, 0x29, 0x2f, 0x29, 0xd9, 0xaf, 0xca, 0x15, 0xd4, 0x12, 0x18, 0x81, 0x5b, 0x04, 0x76, 0xe1, 0xdd, diff --git a/lease/leasepb/lease.pb.go b/lease/leasepb/lease.pb.go index fb3a9bab0..ec8db732b 100644 --- a/lease/leasepb/lease.pb.go +++ b/lease/leasepb/lease.pb.go @@ -590,7 +590,7 @@ func init() { proto.RegisterFile("lease.proto", fileDescriptorLease) } var fileDescriptorLease = []byte{ // 233 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0xe2, 0xce, 0x49, 0x4d, 0x2c, + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0xce, 0x49, 0x4d, 0x2c, 0x4e, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x07, 0x73, 0x0a, 0x92, 0xa4, 0x44, 0xd2, 0xf3, 0xd3, 0xf3, 0xc1, 0x62, 0xfa, 0x20, 0x16, 0x44, 0x5a, 0x4a, 0x2d, 0xb5, 0x24, 0x39, 0x45, 0x1f, 0x44, 0x14, 0xa7, 0x16, 0x95, 0xa5, 0x16, 0x21, 0x31, 0x0b, 0x92, 0xf4, 0x8b, 0x0a, 0x92, diff --git a/mvcc/mvccpb/kv.pb.go b/mvcc/mvccpb/kv.pb.go index aa053f4e6..7033f1326 100644 --- a/mvcc/mvccpb/kv.pb.go +++ b/mvcc/mvccpb/kv.pb.go @@ -713,7 +713,7 @@ func init() { proto.RegisterFile("kv.proto", fileDescriptorKv) } var fileDescriptorKv = []byte{ // 303 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x6c, 0x90, 0x41, 0x4e, 0xc2, 0x40, + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0x41, 0x4e, 0xc2, 0x40, 0x14, 0x86, 0x3b, 0x14, 0x0a, 0x3e, 0x08, 0x36, 0x13, 0x12, 0x27, 0x2e, 0x26, 0x95, 0x8d, 0x18, 0x13, 0x4c, 0xf0, 0x06, 0xc6, 0xae, 0x70, 0x61, 0x1a, 0x74, 0x4b, 0x4a, 0x79, 0x21, 0xa4, 0x94, 0x69, 0x4a, 0x9d, 0xa4, 0x37, 0x71, 0xef, 0xde, 0x73, 0xb0, 0xe4, 0x08, 0x52, 0x2f, 0x62, 0xfa, diff --git a/raft/raftpb/raft.pb.go b/raft/raftpb/raft.pb.go index 86ad31207..3c45eef00 100644 --- a/raft/raftpb/raft.pb.go +++ b/raft/raftpb/raft.pb.go @@ -1847,7 +1847,7 @@ func init() { proto.RegisterFile("raft.proto", fileDescriptorRaft) } var fileDescriptorRaft = []byte{ // 790 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x64, 0x54, 0xcd, 0x6e, 0xdb, 0x46, + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x54, 0xcd, 0x6e, 0xdb, 0x46, 0x10, 0x16, 0x29, 0xea, 0x6f, 0x28, 0xcb, 0xab, 0xb5, 0x5a, 0x2c, 0x0c, 0x43, 0x55, 0x85, 0x1e, 0x04, 0x17, 0x76, 0x5b, 0x1d, 0x7a, 0xe8, 0xcd, 0x96, 0x0a, 0x58, 0x40, 0x65, 0xb8, 0xb2, 0xdc, 0x43, 0x83, 0x20, 0x58, 0x8b, 0x2b, 0x4a, 0x89, 0xc9, 0x25, 0x96, 0x2b, 0xc7, 0xbe, 0x04, 0x79, diff --git a/scripts/genproto.sh b/scripts/genproto.sh index 9b354ff09..e42784745 100755 --- a/scripts/genproto.sh +++ b/scripts/genproto.sh @@ -68,20 +68,19 @@ for dir in ${DIRS}; do popd done -protoc -I. \ - -I${GRPC_GATEWAY_ROOT}/third_party/googleapis \ - -I${GOGOPROTO_PATH} \ - -I${COREOS_ROOT} \ - --grpc-gateway_out=logtostderr=true:. \ - --swagger_out=logtostderr=true:./Documentation/dev-guide/apispec/swagger/. \ - ./etcdserver/etcdserverpb/rpc.proto - -# TODO: change this whenever we add more swagger API -mv \ - Documentation/dev-guide/apispec/swagger/etcdserver/etcdserverpb/rpc.swagger.json \ - Documentation/dev-guide/apispec/swagger/rpc.swagger.json -rm -rf Documentation/dev-guide/apispec/swagger/etcdserver/etcdserverpb - +for pb in etcdserverpb/rpc api/v3lock/v3lockpb/v3lock api/v3election/v3electionpb/v3election; do + protoc -I. \ + -I${GRPC_GATEWAY_ROOT}/third_party/googleapis \ + -I${GOGOPROTO_PATH} \ + -I${COREOS_ROOT} \ + --grpc-gateway_out=logtostderr=true:. \ + --swagger_out=logtostderr=true:./Documentation/dev-guide/apispec/swagger/. \ + ./etcdserver/${pb}.proto + name=`basename ${pb}` + mv Documentation/dev-guide/apispec/swagger/etcdserver/${pb}.swagger.json \ + Documentation/dev-guide/apispec/swagger/${name}.swagger.json +done +rm -rf Documentation/dev-guide/apispec/swagger/etcdserver/ # install protodoc # go get -v -u github.com/coreos/protodoc @@ -106,6 +105,11 @@ if [ "$1" = "-g" ]; then --message-only-from-this-file="etcdserver/etcdserverpb/rpc.proto" \ --disclaimer="This is a generated documentation. Please read the proto files for more." + protodoc --directories="etcdserver/api/v3lock/v3lockpb=service_message,etcdserver/api/v3election/v3electionpb=service_message,mvcc/mvccpb=service_message" \ + --title="etcd concurrency API Reference" \ + --output="Documentation/dev-guide/api_concurrency_reference_v3.md" \ + --disclaimer="This is a generated documentation. Please read the proto files for more." + echo "protodoc is finished..." else echo "skipping grpc API reference document auto-generation..." diff --git a/snap/snappb/snap.pb.go b/snap/snappb/snap.pb.go index 130e2277c..05a77ff9d 100644 --- a/snap/snappb/snap.pb.go +++ b/snap/snappb/snap.pb.go @@ -342,7 +342,7 @@ func init() { proto.RegisterFile("snap.proto", fileDescriptorSnap) } var fileDescriptorSnap = []byte{ // 126 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0xe2, 0x2a, 0xce, 0x4b, 0x2c, + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x2a, 0xce, 0x4b, 0x2c, 0xd0, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x03, 0xb1, 0x0b, 0x92, 0xa4, 0x44, 0xd2, 0xf3, 0xd3, 0xf3, 0xc1, 0x42, 0xfa, 0x20, 0x16, 0x44, 0x56, 0xc9, 0x8c, 0x8b, 0x03, 0x24, 0x5f, 0x9c, 0x91, 0x5f, 0x22, 0x24, 0xc6, 0xc5, 0x9c, 0x5c, 0x94, 0x2c, 0xc1, 0xa8, 0xc0, 0xa8, 0xc1, 0xeb, diff --git a/wal/walpb/record.pb.go b/wal/walpb/record.pb.go index e1a77d5e5..664fae130 100644 --- a/wal/walpb/record.pb.go +++ b/wal/walpb/record.pb.go @@ -506,7 +506,7 @@ func init() { proto.RegisterFile("record.proto", fileDescriptorRecord) } var fileDescriptorRecord = []byte{ // 186 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0xe2, 0x29, 0x4a, 0x4d, 0xce, + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x29, 0x4a, 0x4d, 0xce, 0x2f, 0x4a, 0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x2d, 0x4f, 0xcc, 0x29, 0x48, 0x92, 0x12, 0x49, 0xcf, 0x4f, 0xcf, 0x07, 0x8b, 0xe8, 0x83, 0x58, 0x10, 0x49, 0x25, 0x3f, 0x2e, 0xb6, 0x20, 0xb0, 0x62, 0x21, 0x09, 0x2e, 0x96, 0x92, 0xca, 0x82, 0x54, 0x09, 0x46, 0x05, 0x46, 0x0d, From 93594006dff269452b52cbd59080cd863a9fc0fd Mon Sep 17 00:00:00 2001 From: Anthony Romano Date: Mon, 10 Apr 2017 13:57:12 -0700 Subject: [PATCH 2/3] embed: register grpc-gateway endpoints for v3lock and v3election --- embed/serve.go | 37 +++++++++++++++---------------------- 1 file changed, 15 insertions(+), 22 deletions(-) diff --git a/embed/serve.go b/embed/serve.go index 16f0b97ce..46634b7c5 100644 --- a/embed/serve.go +++ b/embed/serve.go @@ -165,34 +165,27 @@ func servePeerHTTP(l net.Listener, handler http.Handler) error { return srv.Serve(l) } +type registerHandlerFunc func(context.Context, *gw.ServeMux, string, []grpc.DialOption) error + func (sctx *serveCtx) registerGateway(opts []grpc.DialOption) (*gw.ServeMux, error) { ctx := sctx.ctx addr := sctx.l.Addr().String() gwmux := gw.NewServeMux() - err := pb.RegisterKVHandlerFromEndpoint(ctx, gwmux, addr, opts) - if err != nil { - return nil, err + handlers := []registerHandlerFunc{ + pb.RegisterKVHandlerFromEndpoint, + pb.RegisterWatchHandlerFromEndpoint, + pb.RegisterLeaseHandlerFromEndpoint, + pb.RegisterClusterHandlerFromEndpoint, + pb.RegisterMaintenanceHandlerFromEndpoint, + pb.RegisterAuthHandlerFromEndpoint, + v3lockpb.RegisterLockHandlerFromEndpoint, + v3electionpb.RegisterElectionHandlerFromEndpoint, } - err = pb.RegisterWatchHandlerFromEndpoint(ctx, gwmux, addr, opts) - if err != nil { - return nil, err - } - err = pb.RegisterLeaseHandlerFromEndpoint(ctx, gwmux, addr, opts) - if err != nil { - return nil, err - } - err = pb.RegisterClusterHandlerFromEndpoint(ctx, gwmux, addr, opts) - if err != nil { - return nil, err - } - err = pb.RegisterMaintenanceHandlerFromEndpoint(ctx, gwmux, addr, opts) - if err != nil { - return nil, err - } - err = pb.RegisterAuthHandlerFromEndpoint(ctx, gwmux, addr, opts) - if err != nil { - return nil, err + for _, h := range handlers { + if err := h(ctx, gwmux, addr, opts); err != nil { + return nil, err + } } return gwmux, nil } From 2030c850710a1c912521c18d0e25cef8f46bc215 Mon Sep 17 00:00:00 2001 From: Anthony Romano Date: Mon, 10 Apr 2017 14:17:56 -0700 Subject: [PATCH 3/3] test: ignore v3electionpb and v3lockpb for static checks --- test | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test b/test index 325cde746..1090e3ca8 100755 --- a/test +++ b/test @@ -27,7 +27,7 @@ fi COVER=${COVER:-"-cover"} # Hack: gofmt ./ will recursively check the .git directory. So use *.go for gofmt. -IGNORE_PKGS="(cmd|vendor|etcdserverpb|rafttest|gopath.proto)" +IGNORE_PKGS="(cmd|vendor|etcdserverpb|rafttest|gopath.proto|v3lockpb|v3electionpb)" INTEGRATION_PKGS="(integration|e2e|contrib|functional-tester)" # all github.com/coreos/etcd/whatever pkgs that are not auto-generated / tools