mirrors/forgejo
1
0
Fork 0
mirror of https://codeberg.org/forgejo/forgejo.git synced 2025-11-04 00:11:04 +00:00
Code Issues Projects Releases Packages Wiki Activity

Simply remove tidb and deps (#3993)

Browse source
This commit is contained in:
Antoine GIRARD 2018-07-04 22:23:23 +02:00 • committed by techknowlogick
commit 74f9f98f78
397 changed files with 1 additions and 166391 deletions
Download patch file Download diff file Expand all files Collapse all files

174
Gopkg.lock generated
View file

@ -143,17 +143,6 @@
packages = ["."]
revision = "098da33fde5f9220736531b3cb26a2dec86a8367"
[[projects]]
name = "github.com/coreos/etcd"
packages = ["error"]
revision = "01c303113d0a3d5a8075864321c3aedb72035bdd"
[[projects]]
branch = "master"
name = "github.com/coreos/go-etcd"
packages = ["etcd"]
revision = "003851be7bb0694fe3cc457a49529a19388ee7cf"
[[projects]]
branch = "master"
name = "github.com/couchbase/vellum"
@ -306,11 +295,6 @@
packages = ["."]
revision = "cb1d0ca71f42d3ee1bf4aba7daa16099bc31a7e9"
[[projects]]
name = "github.com/go-xorm/tidb"
packages = ["."]
revision = "21e49190ce47a766fa741cf7edc831a30c12c6ac"
[[projects]]
name = "github.com/go-xorm/xorm"
packages = ["."]
@ -370,11 +354,6 @@
packages = ["."]
revision = "8fb95d837f7d6db1913fecfd7bcc5333e6499596"
[[projects]]
name = "github.com/juju/errors"
packages = ["."]
revision = "b2c7a7da5b2995941048f60146e67702a292e468"
[[projects]]
name = "github.com/kballard/go-shellquote"
packages = ["."]
@ -497,134 +476,12 @@
packages = ["."]
revision = "891127d8d1b52734debe1b3c3d7e747502b6c366"
[[projects]]
name = "github.com/ngaut/deadline"
packages = ["."]
revision = "fae8f9dfd7048de16575b9d4c255278e38c28a4f"
[[projects]]
branch = "master"
name = "github.com/ngaut/go-zookeeper"
packages = ["zk"]
revision = "9c3719e318c7cfd072e41eb48cb71fcaa49d5e05"
[[projects]]
name = "github.com/ngaut/log"
packages = ["."]
revision = "d2af3a61f64d093457fb23b25d20f4ce3cd551ce"
[[projects]]
branch = "master"
name = "github.com/ngaut/pools"
packages = ["."]
revision = "b7bc8c42aac787667ba45adea78233f53f548443"
[[projects]]
branch = "master"
name = "github.com/ngaut/sync2"
packages = ["."]
revision = "7a24ed77b2efb460c1468b7dc917821c66e80e55"
[[projects]]
branch = "master"
name = "github.com/ngaut/tso"
packages = [
"client",
"proto",
"util"
]
revision = "118f6c141d58f1e72577ff61f43f649bf39355ee"
[[projects]]
branch = "master"
name = "github.com/ngaut/zkhelper"
packages = ["."]
revision = "6738bdc138d469112c6687fbfcfe049ccabd6a0a"
[[projects]]
branch = "master"
name = "github.com/petar/GoLLRB"
packages = ["llrb"]
revision = "53be0d36a84c2a886ca057d34b6aa4468df9ccb4"
[[projects]]
name = "github.com/philhofer/fwd"
packages = ["."]
revision = "bb6d471dc95d4fe11e432687f8b70ff496cf3136"
version = "v1.0.0"
[[projects]]
name = "github.com/pingcap/go-hbase"
packages = [
".",
"iohelper",
"proto"
]
revision = "7a98d1fe4e9e115de8c77ae0e158c0d08732c550"
[[projects]]
branch = "master"
name = "github.com/pingcap/go-themis"
packages = [
".",
"oracle",
"oracle/oracles"
]
revision = "dbb996606c1d1fe8571fd9ac6da2254c76d2c5c9"
[[projects]]
name = "github.com/pingcap/tidb"
packages = [
".",
"ast",
"column",
"context",
"ddl",
"domain",
"evaluator",
"executor",
"infoschema",
"inspectkv",
"kv",
"kv/memkv",
"meta",
"meta/autoid",
"model",
"mysql",
"optimizer",
"optimizer/plan",
"parser",
"parser/opcode",
"perfschema",
"privilege",
"privilege/privileges",
"sessionctx",
"sessionctx/autocommit",
"sessionctx/db",
"sessionctx/forupdate",
"sessionctx/variable",
"store/hbase",
"store/localstore",
"store/localstore/boltdb",
"store/localstore/engine",
"store/localstore/goleveldb",
"structure",
"table",
"table/tables",
"terror",
"util",
"util/bytes",
"util/charset",
"util/codec",
"util/distinct",
"util/hack",
"util/segmentmap",
"util/sqlexec",
"util/stringutil",
"util/types"
]
revision = "33197485abe227dcb254644cf5081c9a3c281669"
[[projects]]
name = "github.com/pmezard/go-difflib"
packages = ["difflib"]
@ -673,24 +530,6 @@
revision = "12b6f73e6084dad08a7c6e575284b177ecafbc71"
version = "v1.2.1"
[[projects]]
name = "github.com/syndtr/goleveldb"
packages = [
"leveldb",
"leveldb/cache",
"leveldb/comparer",
"leveldb/errors",
"leveldb/filter",
"leveldb/iterator",
"leveldb/journal",
"leveldb/memdb",
"leveldb/opt",
"leveldb/storage",
"leveldb/table",
"leveldb/util"
]
revision = "917f41c560270110ceb73c5b38be2a9127387071"
[[projects]]
branch = "master"
name = "github.com/tinylib/msgp"
@ -703,17 +542,6 @@
packages = ["."]
revision = "d21a03e0b1d9fc1df59ff54e7a513655c1748b0c"
[[projects]]
name = "github.com/twinj/uuid"
packages = ["."]
revision = "89173bcdda19db0eb88aef1e1cb1cb2505561d31"
version = "0.10.0"
[[projects]]
name = "github.com/ugorji/go"
packages = ["codec"]
revision = "c062049c1793b01a3cc3fe786108edabbaf7756b"
[[projects]]
name = "github.com/urfave/cli"
packages = ["."]
@ -873,6 +701,6 @@
[solve-meta]
analyzer-name = "dep"
analyzer-version = 1
inputs-digest = "96c83a3502bd50c5ca8e4d9b4145172267630270e587c79b7253156725eeb9b8"
inputs-digest = "59451a3ad1d449f75c5e9035daf542a377c5c4a397e219bebec0aa0007ab9c39"
solver-name = "gps-cdcl"
solver-version = 1

5
Gopkg.toml
View file

@ -30,11 +30,6 @@ ignored = ["google.golang.org/appengine*"]
revision = "f2499483f923065a842d38eb4c7f1927e6fc6e6d"
name = "golang.org/x/net"
[[constraint]]
#version = "v1.0.0"
revision = "33197485abe227dcb254644cf5081c9a3c281669"
name = "github.com/pingcap/tidb"
[[override]]
name = "github.com/go-xorm/xorm"
#version = "0.6.5"

18
models/models_tidb.go
View file

@ -1,18 +0,0 @@
// +build tidb
// Copyright 2015 The Gogs Authors. All rights reserved.
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.
package models
import (
_ "github.com/go-xorm/tidb"
"github.com/ngaut/log"
_ "github.com/pingcap/tidb"
)
func init() {
EnableTiDB = true
log.SetLevelByString("error")
}

202
vendor/github.com/coreos/etcd/LICENSE generated vendored
View file

@ -1,202 +0,0 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

5
vendor/github.com/coreos/etcd/NOTICE generated vendored
View file

@ -1,5 +0,0 @@
CoreOS Project
Copyright 2014 CoreOS, Inc
This product includes software developed at CoreOS, Inc.
(http://www.coreos.com/).

162
vendor/github.com/coreos/etcd/error/error.go generated vendored
View file

@ -1,162 +0,0 @@
// Copyright 2015 CoreOS, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Package error describes errors in etcd project. When any change happens,
// Documentation/errorcode.md needs to be updated correspondingly.
package error
import (
"encoding/json"
"fmt"
"net/http"
)
var errors = map[int]string{
// command related errors
EcodeKeyNotFound: "Key not found",
EcodeTestFailed: "Compare failed", //test and set
EcodeNotFile: "Not a file",
ecodeNoMorePeer: "Reached the max number of peers in the cluster",
EcodeNotDir: "Not a directory",
EcodeNodeExist: "Key already exists", // create
ecodeKeyIsPreserved: "The prefix of given key is a keyword in etcd",
EcodeRootROnly: "Root is read only",
EcodeDirNotEmpty: "Directory not empty",
ecodeExistingPeerAddr: "Peer address has existed",
EcodeUnauthorized: "The request requires user authentication",
// Post form related errors
ecodeValueRequired: "Value is Required in POST form",
EcodePrevValueRequired: "PrevValue is Required in POST form",
EcodeTTLNaN: "The given TTL in POST form is not a number",
EcodeIndexNaN: "The given index in POST form is not a number",
ecodeValueOrTTLRequired: "Value or TTL is required in POST form",
ecodeTimeoutNaN: "The given timeout in POST form is not a number",
ecodeNameRequired: "Name is required in POST form",
ecodeIndexOrValueRequired: "Index or value is required",
ecodeIndexValueMutex: "Index and value cannot both be specified",
EcodeInvalidField: "Invalid field",
EcodeInvalidForm: "Invalid POST form",
EcodeRefreshValue: "Value provided on refresh",
EcodeRefreshTTLRequired: "A TTL must be provided on refresh",
// raft related errors
EcodeRaftInternal: "Raft Internal Error",
EcodeLeaderElect: "During Leader Election",
// etcd related errors
EcodeWatcherCleared: "watcher is cleared due to etcd recovery",
EcodeEventIndexCleared: "The event in requested index is outdated and cleared",
ecodeStandbyInternal: "Standby Internal Error",
ecodeInvalidActiveSize: "Invalid active size",
ecodeInvalidRemoveDelay: "Standby remove delay",
// client related errors
ecodeClientInternal: "Client Internal Error",
}
var errorStatus = map[int]int{
EcodeKeyNotFound: http.StatusNotFound,
EcodeNotFile: http.StatusForbidden,
EcodeDirNotEmpty: http.StatusForbidden,
EcodeUnauthorized: http.StatusUnauthorized,
EcodeTestFailed: http.StatusPreconditionFailed,
EcodeNodeExist: http.StatusPreconditionFailed,
EcodeRaftInternal: http.StatusInternalServerError,
EcodeLeaderElect: http.StatusInternalServerError,
}
const (
EcodeKeyNotFound = 100
EcodeTestFailed = 101
EcodeNotFile = 102
ecodeNoMorePeer = 103
EcodeNotDir = 104
EcodeNodeExist = 105
ecodeKeyIsPreserved = 106
EcodeRootROnly = 107
EcodeDirNotEmpty = 108
ecodeExistingPeerAddr = 109
EcodeUnauthorized = 110
ecodeValueRequired = 200
EcodePrevValueRequired = 201
EcodeTTLNaN = 202
EcodeIndexNaN = 203
ecodeValueOrTTLRequired = 204
ecodeTimeoutNaN = 205
ecodeNameRequired = 206
ecodeIndexOrValueRequired = 207
ecodeIndexValueMutex = 208
EcodeInvalidField = 209
EcodeInvalidForm = 210
EcodeRefreshValue = 211
EcodeRefreshTTLRequired = 212
EcodeRaftInternal = 300
EcodeLeaderElect = 301
EcodeWatcherCleared = 400
EcodeEventIndexCleared = 401
ecodeStandbyInternal = 402
ecodeInvalidActiveSize = 403
ecodeInvalidRemoveDelay = 404
ecodeClientInternal = 500
)
type Error struct {
ErrorCode int `json:"errorCode"`
Message string `json:"message"`
Cause string `json:"cause,omitempty"`
Index uint64 `json:"index"`
}
func NewRequestError(errorCode int, cause string) *Error {
return NewError(errorCode, cause, 0)
}
func NewError(errorCode int, cause string, index uint64) *Error {
return &Error{
ErrorCode: errorCode,
Message: errors[errorCode],
Cause: cause,
Index: index,
}
}
// Error is for the error interface
func (e Error) Error() string {
return e.Message + " (" + e.Cause + ")"
}
func (e Error) toJsonString() string {
b, _ := json.Marshal(e)
return string(b)
}
func (e Error) StatusCode() int {
status, ok := errorStatus[e.ErrorCode]
if !ok {
status = http.StatusBadRequest
}
return status
}
func (e Error) WriteTo(w http.ResponseWriter) {
w.Header().Add("X-Etcd-Index", fmt.Sprint(e.Index))
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(e.StatusCode())
fmt.Fprintln(w, e.toJsonString())
}

202
vendor/github.com/coreos/go-etcd/LICENSE generated vendored
View file

@ -1,202 +0,0 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

23
vendor/github.com/coreos/go-etcd/etcd/add_child.go generated vendored
View file

@ -1,23 +0,0 @@
package etcd
// Add a new directory with a random etcd-generated key under the given path.
func (c *Client) AddChildDir(key string, ttl uint64) (*Response, error) {
raw, err := c.post(key, "", ttl)
if err != nil {
return nil, err
}
return raw.Unmarshal()
}
// Add a new file with a random etcd-generated key under the given path.
func (c *Client) AddChild(key string, value string, ttl uint64) (*Response, error) {
raw, err := c.post(key, value, ttl)
if err != nil {
return nil, err
}
return raw.Unmarshal()
}

476
vendor/github.com/coreos/go-etcd/etcd/client.go generated vendored
View file

@ -1,476 +0,0 @@
package etcd
import (
"crypto/tls"
"crypto/x509"
"encoding/json"
"errors"
"io"
"io/ioutil"
"math/rand"
"net"
"net/http"
"net/url"
"os"
"path"
"strings"
"time"
)
// See SetConsistency for how to use these constants.
const (
// Using strings rather than iota because the consistency level
// could be persisted to disk, so it'd be better to use
// human-readable values.
STRONG_CONSISTENCY = "STRONG"
WEAK_CONSISTENCY = "WEAK"
)
const (
defaultBufferSize = 10
)
func init() {
rand.Seed(int64(time.Now().Nanosecond()))
}
type Config struct {
CertFile string `json:"certFile"`
KeyFile string `json:"keyFile"`
CaCertFile []string `json:"caCertFiles"`
DialTimeout time.Duration `json:"timeout"`
Consistency string `json:"consistency"`
}
type credentials struct {
username string
password string
}
type Client struct {
config Config `json:"config"`
cluster *Cluster `json:"cluster"`
httpClient *http.Client
credentials *credentials
transport *http.Transport
persistence io.Writer
cURLch chan string
// CheckRetry can be used to control the policy for failed requests
// and modify the cluster if needed.
// The client calls it before sending requests again, and
// stops retrying if CheckRetry returns some error. The cases that
// this function needs to handle include no response and unexpected
// http status code of response.
// If CheckRetry is nil, client will call the default one
// `DefaultCheckRetry`.
// Argument cluster is the etcd.Cluster object that these requests have been made on.
// Argument numReqs is the number of http.Requests that have been made so far.
// Argument lastResp is the http.Responses from the last request.
// Argument err is the reason of the failure.
CheckRetry func(cluster *Cluster, numReqs int,
lastResp http.Response, err error) error
}
// NewClient create a basic client that is configured to be used
// with the given machine list.
func NewClient(machines []string) *Client {
config := Config{
// default timeout is one second
DialTimeout: time.Second,
Consistency: WEAK_CONSISTENCY,
}
client := &Client{
cluster: NewCluster(machines),
config: config,
}
client.initHTTPClient()
client.saveConfig()
return client
}
// NewTLSClient create a basic client with TLS configuration
func NewTLSClient(machines []string, cert, key, caCert string) (*Client, error) {
// overwrite the default machine to use https
if len(machines) == 0 {
machines = []string{"https://127.0.0.1:4001"}
}
config := Config{
// default timeout is one second
DialTimeout: time.Second,
Consistency: WEAK_CONSISTENCY,
CertFile: cert,
KeyFile: key,
CaCertFile: make([]string, 0),
}
client := &Client{
cluster: NewCluster(machines),
config: config,
}
err := client.initHTTPSClient(cert, key)
if err != nil {
return nil, err
}
err = client.AddRootCA(caCert)
client.saveConfig()
return client, nil
}
// NewClientFromFile creates a client from a given file path.
// The given file is expected to use the JSON format.
func NewClientFromFile(fpath string) (*Client, error) {
fi, err := os.Open(fpath)
if err != nil {
return nil, err
}
defer func() {
if err := fi.Close(); err != nil {
panic(err)
}
}()
return NewClientFromReader(fi)
}
// NewClientFromReader creates a Client configured from a given reader.
// The configuration is expected to use the JSON format.
func NewClientFromReader(reader io.Reader) (*Client, error) {
c := new(Client)
b, err := ioutil.ReadAll(reader)
if err != nil {
return nil, err
}
err = json.Unmarshal(b, c)
if err != nil {
return nil, err
}
if c.config.CertFile == "" {
c.initHTTPClient()
} else {
err = c.initHTTPSClient(c.config.CertFile, c.config.KeyFile)
}
if err != nil {
return nil, err
}
for _, caCert := range c.config.CaCertFile {
if err := c.AddRootCA(caCert); err != nil {
return nil, err
}
}
return c, nil
}
// Override the Client's HTTP Transport object
func (c *Client) SetTransport(tr *http.Transport) {
c.httpClient.Transport = tr
c.transport = tr
}
func (c *Client) SetCredentials(username, password string) {
c.credentials = &credentials{username, password}
}
func (c *Client) Close() {
c.transport.DisableKeepAlives = true
c.transport.CloseIdleConnections()
}
// initHTTPClient initializes a HTTP client for etcd client
func (c *Client) initHTTPClient() {
c.transport = &http.Transport{
Dial: c.DefaultDial,
TLSClientConfig: &tls.Config{
InsecureSkipVerify: true,
},
}
c.httpClient = &http.Client{Transport: c.transport}
}
// initHTTPClient initializes a HTTPS client for etcd client
func (c *Client) initHTTPSClient(cert, key string) error {
if cert == "" || key == "" {
return errors.New("Require both cert and key path")
}
tlsCert, err := tls.LoadX509KeyPair(cert, key)
if err != nil {
return err
}
tlsConfig := &tls.Config{
Certificates: []tls.Certificate{tlsCert},
InsecureSkipVerify: true,
}
c.transport = &http.Transport{
TLSClientConfig: tlsConfig,
Dial: c.DefaultDial,
}
c.httpClient = &http.Client{Transport: c.transport}
return nil
}
// SetPersistence sets a writer to which the config will be
// written every time it's changed.
func (c *Client) SetPersistence(writer io.Writer) {
c.persistence = writer
}
// SetConsistency changes the consistency level of the client.
//
// When consistency is set to STRONG_CONSISTENCY, all requests,
// including GET, are sent to the leader. This means that, assuming
// the absence of leader failures, GET requests are guaranteed to see
// the changes made by previous requests.
//
// When consistency is set to WEAK_CONSISTENCY, other requests
// are still sent to the leader, but GET requests are sent to a
// random server from the server pool. This reduces the read
// load on the leader, but it's not guaranteed that the GET requests
// will see changes made by previous requests (they might have not
// yet been committed on non-leader servers).
func (c *Client) SetConsistency(consistency string) error {
if !(consistency == STRONG_CONSISTENCY || consistency == WEAK_CONSISTENCY) {
return errors.New("The argument must be either STRONG_CONSISTENCY or WEAK_CONSISTENCY.")
}
c.config.Consistency = consistency
return nil
}
// Sets the DialTimeout value
func (c *Client) SetDialTimeout(d time.Duration) {
c.config.DialTimeout = d
}
// AddRootCA adds a root CA cert for the etcd client
func (c *Client) AddRootCA(caCert string) error {
if c.httpClient == nil {
return errors.New("Client has not been initialized yet!")
}
certBytes, err := ioutil.ReadFile(caCert)
if err != nil {
return err
}
tr, ok := c.httpClient.Transport.(*http.Transport)
if !ok {
panic("AddRootCA(): Transport type assert should not fail")
}
if tr.TLSClientConfig.RootCAs == nil {
caCertPool := x509.NewCertPool()
ok = caCertPool.AppendCertsFromPEM(certBytes)
if ok {
tr.TLSClientConfig.RootCAs = caCertPool
}
tr.TLSClientConfig.InsecureSkipVerify = false
} else {
ok = tr.TLSClientConfig.RootCAs.AppendCertsFromPEM(certBytes)
}
if !ok {
err = errors.New("Unable to load caCert")
}
c.config.CaCertFile = append(c.config.CaCertFile, caCert)
c.saveConfig()
return err
}
// SetCluster updates cluster information using the given machine list.
func (c *Client) SetCluster(machines []string) bool {
success := c.internalSyncCluster(machines)
return success
}
func (c *Client) GetCluster() []string {
return c.cluster.Machines
}
// SyncCluster updates the cluster information using the internal machine list.
// If no members are found, the intenral machine list is left untouched.
func (c *Client) SyncCluster() bool {
return c.internalSyncCluster(c.cluster.Machines)
}
// internalSyncCluster syncs cluster information using the given machine list.
func (c *Client) internalSyncCluster(machines []string) bool {
// comma-separated list of machines in the cluster.
members := ""
for _, machine := range machines {
httpPath := c.createHttpPath(machine, path.Join(version, "members"))
resp, err := c.httpClient.Get(httpPath)
if err != nil {
// try another machine in the cluster
continue
}
if resp.StatusCode != http.StatusOK { // fall-back to old endpoint
httpPath := c.createHttpPath(machine, path.Join(version, "machines"))
resp, err := c.httpClient.Get(httpPath)
if err != nil {
// try another machine in the cluster
continue
}
b, err := ioutil.ReadAll(resp.Body)
resp.Body.Close()
if err != nil {
// try another machine in the cluster
continue
}
members = string(b)
} else {
b, err := ioutil.ReadAll(resp.Body)
resp.Body.Close()
if err != nil {
// try another machine in the cluster
continue
}
var mCollection memberCollection
if err := json.Unmarshal(b, &mCollection); err != nil {
// try another machine
continue
}
urls := make([]string, 0)
for _, m := range mCollection {
urls = append(urls, m.ClientURLs...)
}
members = strings.Join(urls, ",")
}
// We should never do an empty cluster update.
if members == "" {
continue
}
// update Machines List
c.cluster.updateFromStr(members)
logger.Debug("sync.machines ", c.cluster.Machines)
c.saveConfig()
return true
}
return false
}
// createHttpPath creates a complete HTTP URL.
// serverName should contain both the host name and a port number, if any.
func (c *Client) createHttpPath(serverName string, _path string) string {
u, err := url.Parse(serverName)
if err != nil {
panic(err)
}
u.Path = path.Join(u.Path, _path)
if u.Scheme == "" {
u.Scheme = "http"
}
return u.String()
}
// DefaultDial attempts to open a TCP connection to the provided address, explicitly
// enabling keep-alives with a one-second interval.
func (c *Client) DefaultDial(network, addr string) (net.Conn, error) {
dialer := net.Dialer{
Timeout: c.config.DialTimeout,
KeepAlive: time.Second,
}
return dialer.Dial(network, addr)
}
func (c *Client) OpenCURL() {
c.cURLch = make(chan string, defaultBufferSize)
}
func (c *Client) CloseCURL() {
c.cURLch = nil
}
func (c *Client) sendCURL(command string) {
go func() {
select {
case c.cURLch <- command:
default:
}
}()
}
func (c *Client) RecvCURL() string {
return <-c.cURLch
}
// saveConfig saves the current config using c.persistence.
func (c *Client) saveConfig() error {
if c.persistence != nil {
b, err := json.Marshal(c)
if err != nil {
return err
}
_, err = c.persistence.Write(b)
if err != nil {
return err
}
}
return nil
}
// MarshalJSON implements the Marshaller interface
// as defined by the standard JSON package.
func (c *Client) MarshalJSON() ([]byte, error) {
b, err := json.Marshal(struct {
Config Config `json:"config"`
Cluster *Cluster `json:"cluster"`
}{
Config: c.config,
Cluster: c.cluster,
})
if err != nil {
return nil, err
}
return b, nil
}
// UnmarshalJSON implements the Unmarshaller interface
// as defined by the standard JSON package.
func (c *Client) UnmarshalJSON(b []byte) error {
temp := struct {
Config Config `json:"config"`
Cluster *Cluster `json:"cluster"`
}{}
err := json.Unmarshal(b, &temp)
if err != nil {
return err
}
c.cluster = temp.Cluster
c.config = temp.Config
return nil
}

54
vendor/github.com/coreos/go-etcd/etcd/cluster.go generated vendored
View file

@ -1,54 +0,0 @@
package etcd
import (
"math/rand"
"strings"
"sync"
)
type Cluster struct {
Leader string `json:"leader"`
Machines []string `json:"machines"`
picked int
mu sync.RWMutex
}
func NewCluster(machines []string) *Cluster {
// if an empty slice was sent in then just assume HTTP 4001 on localhost
if len(machines) == 0 {
machines = []string{"http://127.0.0.1:4001"}
}
machines = shuffleStringSlice(machines)
logger.Debug("Shuffle cluster machines", machines)
// default leader and machines
return &Cluster{
Leader: "",
Machines: machines,
picked: rand.Intn(len(machines)),
}
}
func (cl *Cluster) failure() {
cl.mu.Lock()
defer cl.mu.Unlock()
cl.picked = (cl.picked + 1) % len(cl.Machines)
}
func (cl *Cluster) pick() string {
cl.mu.Lock()
defer cl.mu.Unlock()
return cl.Machines[cl.picked]
}
func (cl *Cluster) updateFromStr(machines string) {
cl.mu.Lock()
defer cl.mu.Unlock()
cl.Machines = strings.Split(machines, ",")
for i := range cl.Machines {
cl.Machines[i] = strings.TrimSpace(cl.Machines[i])
}
cl.Machines = shuffleStringSlice(cl.Machines)
cl.picked = rand.Intn(len(cl.Machines))
}

34
vendor/github.com/coreos/go-etcd/etcd/compare_and_delete.go generated vendored
View file

@ -1,34 +0,0 @@
package etcd
import "fmt"
func (c *Client) CompareAndDelete(key string, prevValue string, prevIndex uint64) (*Response, error) {
raw, err := c.RawCompareAndDelete(key, prevValue, prevIndex)
if err != nil {
return nil, err
}
return raw.Unmarshal()
}
func (c *Client) RawCompareAndDelete(key string, prevValue string, prevIndex uint64) (*RawResponse, error) {
if prevValue == "" && prevIndex == 0 {
return nil, fmt.Errorf("You must give either prevValue or prevIndex.")
}
options := Options{}
if prevValue != "" {
options["prevValue"] = prevValue
}
if prevIndex != 0 {
options["prevIndex"] = prevIndex
}
raw, err := c.delete(key, options)
if err != nil {
return nil, err
}
return raw, err
}

36
vendor/github.com/coreos/go-etcd/etcd/compare_and_swap.go generated vendored
View file

@ -1,36 +0,0 @@
package etcd
import "fmt"
func (c *Client) CompareAndSwap(key string, value string, ttl uint64,
prevValue string, prevIndex uint64) (*Response, error) {
raw, err := c.RawCompareAndSwap(key, value, ttl, prevValue, prevIndex)
if err != nil {
return nil, err
}
return raw.Unmarshal()
}
func (c *Client) RawCompareAndSwap(key string, value string, ttl uint64,
prevValue string, prevIndex uint64) (*RawResponse, error) {
if prevValue == "" && prevIndex == 0 {
return nil, fmt.Errorf("You must give either prevValue or prevIndex.")
}
options := Options{}
if prevValue != "" {
options["prevValue"] = prevValue
}
if prevIndex != 0 {
options["prevIndex"] = prevIndex
}
raw, err := c.put(key, value, ttl, options)
if err != nil {
return nil, err
}
return raw, err
}

55
vendor/github.com/coreos/go-etcd/etcd/debug.go generated vendored
View file

@ -1,55 +0,0 @@
package etcd
import (
"fmt"
"io/ioutil"
"log"
"strings"
)
var logger *etcdLogger
func SetLogger(l *log.Logger) {
logger = &etcdLogger{l}
}
func GetLogger() *log.Logger {
return logger.log
}
type etcdLogger struct {
log *log.Logger
}
func (p *etcdLogger) Debug(args ...interface{}) {
msg := "DEBUG: " + fmt.Sprint(args...)
p.log.Println(msg)
}
func (p *etcdLogger) Debugf(f string, args ...interface{}) {
msg := "DEBUG: " + fmt.Sprintf(f, args...)
// Append newline if necessary
if !strings.HasSuffix(msg, "\n") {
msg = msg + "\n"
}
p.log.Print(msg)
}
func (p *etcdLogger) Warning(args ...interface{}) {
msg := "WARNING: " + fmt.Sprint(args...)
p.log.Println(msg)
}
func (p *etcdLogger) Warningf(f string, args ...interface{}) {
msg := "WARNING: " + fmt.Sprintf(f, args...)
// Append newline if necessary
if !strings.HasSuffix(msg, "\n") {
msg = msg + "\n"
}
p.log.Print(msg)
}
func init() {
// Default logger uses the go default log.
SetLogger(log.New(ioutil.Discard, "go-etcd", log.LstdFlags))
}

40
vendor/github.com/coreos/go-etcd/etcd/delete.go generated vendored
View file

@ -1,40 +0,0 @@
package etcd
// Delete deletes the given key.
//
// When recursive set to false, if the key points to a
// directory the method will fail.
//
// When recursive set to true, if the key points to a file,
// the file will be deleted; if the key points to a directory,
// then everything under the directory (including all child directories)
// will be deleted.
func (c *Client) Delete(key string, recursive bool) (*Response, error) {
raw, err := c.RawDelete(key, recursive, false)
if err != nil {
return nil, err
}
return raw.Unmarshal()
}
// DeleteDir deletes an empty directory or a key value pair
func (c *Client) DeleteDir(key string) (*Response, error) {
raw, err := c.RawDelete(key, false, true)
if err != nil {
return nil, err
}
return raw.Unmarshal()
}
func (c *Client) RawDelete(key string, recursive bool, dir bool) (*RawResponse, error) {
ops := Options{
"recursive": recursive,
"dir": dir,
}
return c.delete(key, ops)
}

49
vendor/github.com/coreos/go-etcd/etcd/error.go generated vendored
View file

@ -1,49 +0,0 @@
package etcd
import (
"encoding/json"
"fmt"
)
const (
ErrCodeEtcdNotReachable = 501
ErrCodeUnhandledHTTPStatus = 502
)
var (
errorMap = map[int]string{
ErrCodeEtcdNotReachable: "All the given peers are not reachable",
}
)
type EtcdError struct {
ErrorCode int `json:"errorCode"`
Message string `json:"message"`
Cause string `json:"cause,omitempty"`
Index uint64 `json:"index"`
}
func (e EtcdError) Error() string {
return fmt.Sprintf("%v: %v (%v) [%v]", e.ErrorCode, e.Message, e.Cause, e.Index)
}
func newError(errorCode int, cause string, index uint64) *EtcdError {
return &EtcdError{
ErrorCode: errorCode,
Message: errorMap[errorCode],
Cause: cause,
Index: index,
}
}
func handleError(b []byte) error {
etcdErr := new(EtcdError)
err := json.Unmarshal(b, etcdErr)
if err != nil {
logger.Warningf("cannot unmarshal etcd error: %v", err)
return err
}
return etcdErr
}

32
vendor/github.com/coreos/go-etcd/etcd/get.go generated vendored
View file

@ -1,32 +0,0 @@
package etcd
// Get gets the file or directory associated with the given key.
// If the key points to a directory, files and directories under
// it will be returned in sorted or unsorted order, depending on
// the sort flag.
// If recursive is set to false, contents under child directories
// will not be returned.
// If recursive is set to true, all the contents will be returned.
func (c *Client) Get(key string, sort, recursive bool) (*Response, error) {
raw, err := c.RawGet(key, sort, recursive)
if err != nil {
return nil, err
}
return raw.Unmarshal()
}
func (c *Client) RawGet(key string, sort, recursive bool) (*RawResponse, error) {
var q bool
if c.config.Consistency == STRONG_CONSISTENCY {
q = true
}
ops := Options{
"recursive": recursive,
"sorted": sort,
"quorum": q,
}
return c.get(key, ops)
}

30
vendor/github.com/coreos/go-etcd/etcd/member.go generated vendored
View file

@ -1,30 +0,0 @@
package etcd
import "encoding/json"
type Member struct {
ID string `json:"id"`
Name string `json:"name"`
PeerURLs []string `json:"peerURLs"`
ClientURLs []string `json:"clientURLs"`
}
type memberCollection []Member
func (c *memberCollection) UnmarshalJSON(data []byte) error {
d := struct {
Members []Member
}{}
if err := json.Unmarshal(data, &d); err != nil {
return err
}
if d.Members == nil {
*c = make([]Member, 0)
return nil
}
*c = d.Members
return nil
}

72
vendor/github.com/coreos/go-etcd/etcd/options.go generated vendored
View file

@ -1,72 +0,0 @@
package etcd
import (
"fmt"
"net/url"
"reflect"
)
type Options map[string]interface{}
// An internally-used data structure that represents a mapping
// between valid options and their kinds
type validOptions map[string]reflect.Kind
// Valid options for GET, PUT, POST, DELETE
// Using CAPITALIZED_UNDERSCORE to emphasize that these
// values are meant to be used as constants.
var (
VALID_GET_OPTIONS = validOptions{
"recursive": reflect.Bool,
"quorum": reflect.Bool,
"sorted": reflect.Bool,
"wait": reflect.Bool,
"waitIndex": reflect.Uint64,
}
VALID_PUT_OPTIONS = validOptions{
"prevValue": reflect.String,
"prevIndex": reflect.Uint64,
"prevExist": reflect.Bool,
"dir": reflect.Bool,
}
VALID_POST_OPTIONS = validOptions{}
VALID_DELETE_OPTIONS = validOptions{
"recursive": reflect.Bool,
"dir": reflect.Bool,
"prevValue": reflect.String,
"prevIndex": reflect.Uint64,
}
)
// Convert options to a string of HTML parameters
func (ops Options) toParameters(validOps validOptions) (string, error) {
p := "?"
values := url.Values{}
if ops == nil {
return "", nil
}
for k, v := range ops {
// Check if the given option is valid (that it exists)
kind := validOps[k]
if kind == reflect.Invalid {
return "", fmt.Errorf("Invalid option: %v", k)
}
// Check if the given option is of the valid type
t := reflect.TypeOf(v)
if kind != t.Kind() {
return "", fmt.Errorf("Option %s should be of %v kind, not of %v kind.",
k, kind, t.Kind())
}
values.Set(k, fmt.Sprintf("%v", v))
}
p += values.Encode()
return p, nil
}

403
vendor/github.com/coreos/go-etcd/etcd/requests.go generated vendored
View file

@ -1,403 +0,0 @@
package etcd
import (
"errors"
"fmt"
"io"
"io/ioutil"
"net/http"
"net/url"
"path"
"strings"
"sync"
"time"
)
// Errors introduced by handling requests
var (
ErrRequestCancelled = errors.New("sending request is cancelled")
)
type RawRequest struct {
Method string
RelativePath string
Values url.Values
Cancel <-chan bool
}
// NewRawRequest returns a new RawRequest
func NewRawRequest(method, relativePath string, values url.Values, cancel <-chan bool) *RawRequest {
return &RawRequest{
Method: method,
RelativePath: relativePath,
Values: values,
Cancel: cancel,
}
}
// getCancelable issues a cancelable GET request
func (c *Client) getCancelable(key string, options Options,
cancel <-chan bool) (*RawResponse, error) {
logger.Debugf("get %s [%s]", key, c.cluster.pick())
p := keyToPath(key)
str, err := options.toParameters(VALID_GET_OPTIONS)
if err != nil {
return nil, err
}
p += str
req := NewRawRequest("GET", p, nil, cancel)
resp, err := c.SendRequest(req)
if err != nil {
return nil, err
}
return resp, nil
}
// get issues a GET request
func (c *Client) get(key string, options Options) (*RawResponse, error) {
return c.getCancelable(key, options, nil)
}
// put issues a PUT request
func (c *Client) put(key string, value string, ttl uint64,
options Options) (*RawResponse, error) {
logger.Debugf("put %s, %s, ttl: %d, [%s]", key, value, ttl, c.cluster.pick())
p := keyToPath(key)
str, err := options.toParameters(VALID_PUT_OPTIONS)
if err != nil {
return nil, err
}
p += str
req := NewRawRequest("PUT", p, buildValues(value, ttl), nil)
resp, err := c.SendRequest(req)
if err != nil {
return nil, err
}
return resp, nil
}
// post issues a POST request
func (c *Client) post(key string, value string, ttl uint64) (*RawResponse, error) {
logger.Debugf("post %s, %s, ttl: %d, [%s]", key, value, ttl, c.cluster.pick())
p := keyToPath(key)
req := NewRawRequest("POST", p, buildValues(value, ttl), nil)
resp, err := c.SendRequest(req)
if err != nil {
return nil, err
}
return resp, nil
}
// delete issues a DELETE request
func (c *Client) delete(key string, options Options) (*RawResponse, error) {
logger.Debugf("delete %s [%s]", key, c.cluster.pick())
p := keyToPath(key)
str, err := options.toParameters(VALID_DELETE_OPTIONS)
if err != nil {
return nil, err
}
p += str
req := NewRawRequest("DELETE", p, nil, nil)
resp, err := c.SendRequest(req)
if err != nil {
return nil, err
}
return resp, nil
}
// SendRequest sends a HTTP request and returns a Response as defined by etcd
func (c *Client) SendRequest(rr *RawRequest) (*RawResponse, error) {
var req *http.Request
var resp *http.Response
var httpPath string
var err error
var respBody []byte
var numReqs = 1
checkRetry := c.CheckRetry
if checkRetry == nil {
checkRetry = DefaultCheckRetry
}
cancelled := make(chan bool, 1)
reqLock := new(sync.Mutex)
if rr.Cancel != nil {
cancelRoutine := make(chan bool)
defer close(cancelRoutine)
go func() {
select {
case <-rr.Cancel:
cancelled <- true
logger.Debug("send.request is cancelled")
case <-cancelRoutine:
return
}
// Repeat canceling request until this thread is stopped
// because we have no idea about whether it succeeds.
for {
reqLock.Lock()
c.httpClient.Transport.(*http.Transport).CancelRequest(req)
reqLock.Unlock()
select {
case <-time.After(100 * time.Millisecond):
case <-cancelRoutine:
return
}
}
}()
}
// If we connect to a follower and consistency is required, retry until
// we connect to a leader
sleep := 25 * time.Millisecond
maxSleep := time.Second
for attempt := 0; ; attempt++ {
if attempt > 0 {
select {
case <-cancelled:
return nil, ErrRequestCancelled
case <-time.After(sleep):
sleep = sleep * 2
if sleep > maxSleep {
sleep = maxSleep
}
}
}
logger.Debug("Connecting to etcd: attempt ", attempt+1, " for ", rr.RelativePath)
// get httpPath if not set
if httpPath == "" {
httpPath = c.getHttpPath(rr.RelativePath)
}
// Return a cURL command if curlChan is set
if c.cURLch != nil {
command := fmt.Sprintf("curl -X %s %s", rr.Method, httpPath)
for key, value := range rr.Values {
command += fmt.Sprintf(" -d %s=%s", key, value[0])
}
if c.credentials != nil {
command += fmt.Sprintf(" -u %s", c.credentials.username)
}
c.sendCURL(command)
}
logger.Debug("send.request.to ", httpPath, " | method ", rr.Method)
req, err := func() (*http.Request, error) {
reqLock.Lock()
defer reqLock.Unlock()
if rr.Values == nil {
if req, err = http.NewRequest(rr.Method, httpPath, nil); err != nil {
return nil, err
}
} else {
body := strings.NewReader(rr.Values.Encode())
if req, err = http.NewRequest(rr.Method, httpPath, body); err != nil {
return nil, err
}
req.Header.Set("Content-Type",
"application/x-www-form-urlencoded; param=value")
}
return req, nil
}()
if err != nil {
return nil, err
}
if c.credentials != nil {
req.SetBasicAuth(c.credentials.username, c.credentials.password)
}
resp, err = c.httpClient.Do(req)
// clear previous httpPath
httpPath = ""
defer func() {
if resp != nil {
resp.Body.Close()
}
}()
// If the request was cancelled, return ErrRequestCancelled directly
select {
case <-cancelled:
return nil, ErrRequestCancelled
default:
}
numReqs++
// network error, change a machine!
if err != nil {
logger.Debug("network error: ", err.Error())
lastResp := http.Response{}
if checkErr := checkRetry(c.cluster, numReqs, lastResp, err); checkErr != nil {
return nil, checkErr
}
c.cluster.failure()
continue
}
// if there is no error, it should receive response
logger.Debug("recv.response.from ", httpPath)
if validHttpStatusCode[resp.StatusCode] {
// try to read byte code and break the loop
respBody, err = ioutil.ReadAll(resp.Body)
if err == nil {
logger.Debug("recv.success ", httpPath)
break
}
// ReadAll error may be caused due to cancel request
select {
case <-cancelled:
return nil, ErrRequestCancelled
default:
}
if err == io.ErrUnexpectedEOF {
// underlying connection was closed prematurely, probably by timeout
// TODO: empty body or unexpectedEOF can cause http.Transport to get hosed;
// this allows the client to detect that and take evasive action. Need
// to revisit once code.google.com/p/go/issues/detail?id=8648 gets fixed.
respBody = []byte{}
break
}
}
if resp.StatusCode == http.StatusTemporaryRedirect {
u, err := resp.Location()
if err != nil {
logger.Warning(err)
} else {
// set httpPath for following redirection
httpPath = u.String()
}
resp.Body.Close()
continue
}
if checkErr := checkRetry(c.cluster, numReqs, *resp,
errors.New("Unexpected HTTP status code")); checkErr != nil {
return nil, checkErr
}
resp.Body.Close()
}
r := &RawResponse{
StatusCode: resp.StatusCode,
Body: respBody,
Header: resp.Header,
}
return r, nil
}
// DefaultCheckRetry defines the retrying behaviour for bad HTTP requests
// If we have retried 2 * machine number, stop retrying.
// If status code is InternalServerError, sleep for 200ms.
func DefaultCheckRetry(cluster *Cluster, numReqs int, lastResp http.Response,
err error) error {
if numReqs > 2*len(cluster.Machines) {
errStr := fmt.Sprintf("failed to propose on members %v twice [last error: %v]", cluster.Machines, err)
return newError(ErrCodeEtcdNotReachable, errStr, 0)
}
if isEmptyResponse(lastResp) {
// always retry if it failed to get response from one machine
return nil
}
if !shouldRetry(lastResp) {
body := []byte("nil")
if lastResp.Body != nil {
if b, err := ioutil.ReadAll(lastResp.Body); err == nil {
body = b
}
}
errStr := fmt.Sprintf("unhandled http status [%s] with body [%s]", http.StatusText(lastResp.StatusCode), body)
return newError(ErrCodeUnhandledHTTPStatus, errStr, 0)
}
// sleep some time and expect leader election finish
time.Sleep(time.Millisecond * 200)
logger.Warning("bad response status code ", lastResp.StatusCode)
return nil
}
func isEmptyResponse(r http.Response) bool { return r.StatusCode == 0 }
// shouldRetry returns whether the reponse deserves retry.
func shouldRetry(r http.Response) bool {
// TODO: only retry when the cluster is in leader election
// We cannot do it exactly because etcd doesn't support it well.
return r.StatusCode == http.StatusInternalServerError
}
func (c *Client) getHttpPath(s ...string) string {
fullPath := c.cluster.pick() + "/" + version
for _, seg := range s {
fullPath = fullPath + "/" + seg
}
return fullPath
}
// buildValues builds a url.Values map according to the given value and ttl
func buildValues(value string, ttl uint64) url.Values {
v := url.Values{}
if value != "" {
v.Set("value", value)
}
if ttl > 0 {
v.Set("ttl", fmt.Sprintf("%v", ttl))
}
return v
}
// convert key string to http path exclude version, including URL escaping
// for example: key[foo] -> path[keys/foo]
// key[/%z] -> path[keys/%25z]
// key[/] -> path[keys/]
func keyToPath(key string) string {
// URL-escape our key, except for slashes
p := strings.Replace(url.QueryEscape(path.Join("keys", key)), "%2F", "/", -1)
// corner case: if key is "/" or "//" ect
// path join will clear the tailing "/"
// we need to add it back
if p == "keys" {
p = "keys/"
}
return p
}

1587
vendor/github.com/coreos/go-etcd/etcd/response.generated.go generated vendored
View file

File diff suppressed because it is too large Load diff

93
vendor/github.com/coreos/go-etcd/etcd/response.go generated vendored
View file

@ -1,93 +0,0 @@
package etcd
//go:generate codecgen -d 1978 -o response.generated.go response.go
import (
"net/http"
"strconv"
"time"
"github.com/ugorji/go/codec"
)
const (
rawResponse = iota
normalResponse
)
type responseType int
type RawResponse struct {
StatusCode int
Body []byte
Header http.Header
}
var (
validHttpStatusCode = map[int]bool{
http.StatusCreated: true,
http.StatusOK: true,
http.StatusBadRequest: true,
http.StatusNotFound: true,
http.StatusPreconditionFailed: true,
http.StatusForbidden: true,
http.StatusUnauthorized: true,
}
)
// Unmarshal parses RawResponse and stores the result in Response
func (rr *RawResponse) Unmarshal() (*Response, error) {
if rr.StatusCode != http.StatusOK && rr.StatusCode != http.StatusCreated {
return nil, handleError(rr.Body)
}
resp := new(Response)
err := codec.NewDecoderBytes(rr.Body, new(codec.JsonHandle)).Decode(resp)
if err != nil {
return nil, err
}
// attach index and term to response
resp.EtcdIndex, _ = strconv.ParseUint(rr.Header.Get("X-Etcd-Index"), 10, 64)
resp.RaftIndex, _ = strconv.ParseUint(rr.Header.Get("X-Raft-Index"), 10, 64)
resp.RaftTerm, _ = strconv.ParseUint(rr.Header.Get("X-Raft-Term"), 10, 64)
return resp, nil
}
type Response struct {
Action string `json:"action"`
Node *Node `json:"node"`
PrevNode *Node `json:"prevNode,omitempty"`
EtcdIndex uint64 `json:"etcdIndex"`
RaftIndex uint64 `json:"raftIndex"`
RaftTerm uint64 `json:"raftTerm"`
}
type Node struct {
Key string `json:"key, omitempty"`
Value string `json:"value,omitempty"`
Dir bool `json:"dir,omitempty"`
Expiration *time.Time `json:"expiration,omitempty"`
TTL int64 `json:"ttl,omitempty"`
Nodes Nodes `json:"nodes,omitempty"`
ModifiedIndex uint64 `json:"modifiedIndex,omitempty"`
CreatedIndex uint64 `json:"createdIndex,omitempty"`
}
type Nodes []*Node
// interfaces for sorting
func (ns Nodes) Len() int {
return len(ns)
}
func (ns Nodes) Less(i, j int) bool {
return ns[i].Key < ns[j].Key
}
func (ns Nodes) Swap(i, j int) {
ns[i], ns[j] = ns[j], ns[i]
}

137
vendor/github.com/coreos/go-etcd/etcd/set_update_create.go generated vendored
View file

@ -1,137 +0,0 @@
package etcd
// Set sets the given key to the given value.
// It will create a new key value pair or replace the old one.
// It will not replace a existing directory.
func (c *Client) Set(key string, value string, ttl uint64) (*Response, error) {
raw, err := c.RawSet(key, value, ttl)
if err != nil {
return nil, err
}
return raw.Unmarshal()
}
// SetDir sets the given key to a directory.
// It will create a new directory or replace the old key value pair by a directory.
// It will not replace a existing directory.
func (c *Client) SetDir(key string, ttl uint64) (*Response, error) {
raw, err := c.RawSetDir(key, ttl)
if err != nil {
return nil, err
}
return raw.Unmarshal()
}
// CreateDir creates a directory. It succeeds only if
// the given key does not yet exist.
func (c *Client) CreateDir(key string, ttl uint64) (*Response, error) {
raw, err := c.RawCreateDir(key, ttl)
if err != nil {
return nil, err
}
return raw.Unmarshal()
}
// UpdateDir updates the given directory. It succeeds only if the
// given key already exists.
func (c *Client) UpdateDir(key string, ttl uint64) (*Response, error) {
raw, err := c.RawUpdateDir(key, ttl)
if err != nil {
return nil, err
}
return raw.Unmarshal()
}
// Create creates a file with the given value under the given key. It succeeds
// only if the given key does not yet exist.
func (c *Client) Create(key string, value string, ttl uint64) (*Response, error) {
raw, err := c.RawCreate(key, value, ttl)
if err != nil {
return nil, err
}
return raw.Unmarshal()
}
// CreateInOrder creates a file with a key that's guaranteed to be higher than other
// keys in the given directory. It is useful for creating queues.
func (c *Client) CreateInOrder(dir string, value string, ttl uint64) (*Response, error) {
raw, err := c.RawCreateInOrder(dir, value, ttl)
if err != nil {
return nil, err
}
return raw.Unmarshal()
}
// Update updates the given key to the given value. It succeeds only if the
// given key already exists.
func (c *Client) Update(key string, value string, ttl uint64) (*Response, error) {
raw, err := c.RawUpdate(key, value, ttl)
if err != nil {
return nil, err
}
return raw.Unmarshal()
}
func (c *Client) RawUpdateDir(key string, ttl uint64) (*RawResponse, error) {
ops := Options{
"prevExist": true,
"dir": true,
}
return c.put(key, "", ttl, ops)
}
func (c *Client) RawCreateDir(key string, ttl uint64) (*RawResponse, error) {
ops := Options{
"prevExist": false,
"dir": true,
}
return c.put(key, "", ttl, ops)
}
func (c *Client) RawSet(key string, value string, ttl uint64) (*RawResponse, error) {
return c.put(key, value, ttl, nil)
}
func (c *Client) RawSetDir(key string, ttl uint64) (*RawResponse, error) {
ops := Options{
"dir": true,
}
return c.put(key, "", ttl, ops)
}
func (c *Client) RawUpdate(key string, value string, ttl uint64) (*RawResponse, error) {
ops := Options{
"prevExist": true,
}
return c.put(key, value, ttl, ops)
}
func (c *Client) RawCreate(key string, value string, ttl uint64) (*RawResponse, error) {
ops := Options{
"prevExist": false,
}
return c.put(key, value, ttl, ops)
}
func (c *Client) RawCreateInOrder(dir string, value string, ttl uint64) (*RawResponse, error) {
return c.post(dir, value, ttl)
}

19
vendor/github.com/coreos/go-etcd/etcd/shuffle.go generated vendored
View file

@ -1,19 +0,0 @@
package etcd
import (
"math/rand"
)
func shuffleStringSlice(cards []string) []string {
size := len(cards)
//Do not need to copy if nothing changed
if size <= 1 {
return cards
}
shuffled := make([]string, size)
index := rand.Perm(size)
for i := range cards {
shuffled[index[i]] = cards[i]
}
return shuffled
}

6
vendor/github.com/coreos/go-etcd/etcd/version.go generated vendored
View file

@ -1,6 +0,0 @@
package etcd
const (
version = "v2"
packageVersion = "v2.0.0+git"
)

103
vendor/github.com/coreos/go-etcd/etcd/watch.go generated vendored
View file

@ -1,103 +0,0 @@
package etcd
import (
"errors"
)
// Errors introduced by the Watch command.
var (
ErrWatchStoppedByUser = errors.New("Watch stopped by the user via stop channel")
)
// If recursive is set to true the watch returns the first change under the given
// prefix since the given index.
//
// If recursive is set to false the watch returns the first change to the given key
// since the given index.
//
// To watch for the latest change, set waitIndex = 0.
//
// If a receiver channel is given, it will be a long-term watch. Watch will block at the
//channel. After someone receives the channel, it will go on to watch that
// prefix. If a stop channel is given, the client can close long-term watch using
// the stop channel.
func (c *Client) Watch(prefix string, waitIndex uint64, recursive bool,
receiver chan *Response, stop chan bool) (*Response, error) {
logger.Debugf("watch %s [%s]", prefix, c.cluster.Leader)
if receiver == nil {
raw, err := c.watchOnce(prefix, waitIndex, recursive, stop)
if err != nil {
return nil, err
}
return raw.Unmarshal()
}
defer close(receiver)
for {
raw, err := c.watchOnce(prefix, waitIndex, recursive, stop)
if err != nil {
return nil, err
}
resp, err := raw.Unmarshal()
if err != nil {
return nil, err
}
waitIndex = resp.Node.ModifiedIndex + 1
receiver <- resp
}
}
func (c *Client) RawWatch(prefix string, waitIndex uint64, recursive bool,
receiver chan *RawResponse, stop chan bool) (*RawResponse, error) {
logger.Debugf("rawWatch %s [%s]", prefix, c.cluster.Leader)
if receiver == nil {
return c.watchOnce(prefix, waitIndex, recursive, stop)
}
for {
raw, err := c.watchOnce(prefix, waitIndex, recursive, stop)
if err != nil {
return nil, err
}
resp, err := raw.Unmarshal()
if err != nil {
return nil, err
}
waitIndex = resp.Node.ModifiedIndex + 1
receiver <- raw
}
}
// helper func
// return when there is change under the given prefix
func (c *Client) watchOnce(key string, waitIndex uint64, recursive bool, stop chan bool) (*RawResponse, error) {
options := Options{
"wait": true,
}
if waitIndex > 0 {
options["waitIndex"] = waitIndex
}
if recursive {
options["recursive"] = true
}
resp, err := c.getCancelable(key, options, stop)
if err == ErrRequestCancelled {
return nil, ErrWatchStoppedByUser
}
return resp, err
}

326
vendor/github.com/go-xorm/tidb/tidb_dialect.go generated vendored
View file

@ -1,326 +0,0 @@
// Copyright 2015 The Xorm Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package tidb
import (
"errors"
"fmt"
"strconv"
"strings"
"github.com/go-xorm/core"
)
type tidb struct {
core.Base
}
func (db *tidb) Init(d *core.DB, uri *core.Uri, drivername, dataSourceName string) error {
return db.Base.Init(d, db, uri, drivername, dataSourceName)
}
func (db *tidb) SqlType(c *core.Column) string {
var res string
switch t := c.SQLType.Name; t {
case core.Bool:
res = core.Bool
case core.Serial:
c.IsAutoIncrement = true
c.IsPrimaryKey = true
c.Nullable = false
res = core.Int
case core.BigSerial:
c.IsAutoIncrement = true
c.IsPrimaryKey = true
c.Nullable = false
res = core.BigInt
case core.Bytea:
res = core.Blob
case core.TimeStampz:
res = core.Char
c.Length = 64
case core.Enum: //mysql enum
res = core.Enum
res += "("
opts := ""
for v, _ := range c.EnumOptions {
opts += fmt.Sprintf(",'%v'", v)
}
res += strings.TrimLeft(opts, ",")
res += ")"
case core.Set: //mysql set
res = core.Set
res += "("
opts := ""
for v, _ := range c.SetOptions {
opts += fmt.Sprintf(",'%v'", v)
}
res += strings.TrimLeft(opts, ",")
res += ")"
case core.NVarchar:
res = core.Varchar
case core.Uuid:
res = core.Varchar
c.Length = 40
case core.Json:
res = core.Text
default:
res = t
}
var hasLen1 bool = (c.Length > 0)
var hasLen2 bool = (c.Length2 > 0)
if res == core.BigInt && !hasLen1 && !hasLen2 {
c.Length = 20
hasLen1 = true
}
if hasLen2 {
res += "(" + strconv.Itoa(c.Length) + "," + strconv.Itoa(c.Length2) + ")"
} else if hasLen1 {
res += "(" + strconv.Itoa(c.Length) + ")"
}
return res
}
func (db *tidb) SupportInsertMany() bool {
return true
}
func (db *tidb) IsReserved(name string) bool {
return false
}
func (db *tidb) Quote(name string) string {
return "`" + name + "`"
}
func (db *tidb) QuoteStr() string {
return "`"
}
func (db *tidb) SupportEngine() bool {
return false
}
func (db *tidb) AutoIncrStr() string {
return "AUTO_INCREMENT"
}
func (db *tidb) SupportCharset() bool {
return false
}
func (db *tidb) IndexOnTable() bool {
return true
}
func (db *tidb) IndexCheckSql(tableName, idxName string) (string, []interface{}) {
args := []interface{}{db.DbName, tableName, idxName}
sql := "SELECT `INDEX_NAME` FROM `INFORMATION_SCHEMA`.`STATISTICS`"
sql += " WHERE `TABLE_SCHEMA` = ? AND `TABLE_NAME` = ? AND `INDEX_NAME`=?"
return sql, args
}
func (db *tidb) TableCheckSql(tableName string) (string, []interface{}) {
args := []interface{}{db.DbName, tableName}
sql := "SELECT `TABLE_NAME` from `INFORMATION_SCHEMA`.`TABLES` WHERE `TABLE_SCHEMA`=? and `TABLE_NAME`=?"
return sql, args
}
func (db *tidb) GetColumns(tableName string) ([]string, map[string]*core.Column, error) {
args := []interface{}{db.DbName, tableName}
s := "SELECT `COLUMN_NAME`, `IS_NULLABLE`, `COLUMN_DEFAULT`, `COLUMN_TYPE`," +
" `COLUMN_KEY`, `EXTRA` FROM `INFORMATION_SCHEMA`.`COLUMNS` WHERE `TABLE_SCHEMA` = ? AND `TABLE_NAME` = ?"
rows, err := db.DB().Query(s, args...)
db.LogSQL(s, args)
if err != nil {
return nil, nil, err
}
defer rows.Close()
cols := make(map[string]*core.Column)
colSeq := make([]string, 0)
for rows.Next() {
col := new(core.Column)
col.Indexes = make(map[string]int)
var columnName, isNullable, colType, colKey, extra string
var colDefault *string
err = rows.Scan(&columnName, &isNullable, &colDefault, &colType, &colKey, &extra)
if err != nil {
return nil, nil, err
}
col.Name = strings.Trim(columnName, "` ")
if "YES" == isNullable {
col.Nullable = true
}
if colDefault != nil {
col.Default = *colDefault
if col.Default == "" {
col.DefaultIsEmpty = true
}
}
cts := strings.Split(colType, "(")
colName := cts[0]
colType = strings.ToUpper(colName)
var len1, len2 int
if len(cts) == 2 {
idx := strings.Index(cts[1], ")")
if colType == core.Enum && cts[1][0] == '\'' { //enum
options := strings.Split(cts[1][0:idx], ",")
col.EnumOptions = make(map[string]int)
for k, v := range options {
v = strings.TrimSpace(v)
v = strings.Trim(v, "'")
col.EnumOptions[v] = k
}
} else if colType == core.Set && cts[1][0] == '\'' {
options := strings.Split(cts[1][0:idx], ",")
col.SetOptions = make(map[string]int)
for k, v := range options {
v = strings.TrimSpace(v)
v = strings.Trim(v, "'")
col.SetOptions[v] = k
}
} else {
lens := strings.Split(cts[1][0:idx], ",")
len1, err = strconv.Atoi(strings.TrimSpace(lens[0]))
if err != nil {
return nil, nil, err
}
if len(lens) == 2 {
len2, err = strconv.Atoi(lens[1])
if err != nil {
return nil, nil, err
}
}
}
}
if colType == "FLOAT UNSIGNED" {
colType = "FLOAT"
}
col.Length = len1
col.Length2 = len2
if _, ok := core.SqlTypes[colType]; ok {
col.SQLType = core.SQLType{colType, len1, len2}
} else {
return nil, nil, errors.New(fmt.Sprintf("unkonw colType %v", colType))
}
if colKey == "PRI" {
col.IsPrimaryKey = true
}
if colKey == "UNI" {
//col.is
}
if extra == "auto_increment" {
col.IsAutoIncrement = true
}
if col.SQLType.IsText() || col.SQLType.IsTime() {
if col.Default != "" {
col.Default = "'" + col.Default + "'"
} else {
if col.DefaultIsEmpty {
col.Default = "''"
}
}
}
cols[col.Name] = col
colSeq = append(colSeq, col.Name)
}
return colSeq, cols, nil
}
func (db *tidb) GetTables() ([]*core.Table, error) {
args := []interface{}{db.DbName}
s := "SELECT `TABLE_NAME`, `ENGINE`, `TABLE_ROWS`, `AUTO_INCREMENT` from " +
"`INFORMATION_SCHEMA`.`TABLES` WHERE `TABLE_SCHEMA`=? AND (`ENGINE`='MyISAM' OR `ENGINE` = 'InnoDB')"
rows, err := db.DB().Query(s, args...)
db.LogSQL(s, args)
if err != nil {
return nil, err
}
defer rows.Close()
tables := make([]*core.Table, 0)
for rows.Next() {
table := core.NewEmptyTable()
var name, engine, tableRows string
var autoIncr *string
err = rows.Scan(&name, &engine, &tableRows, &autoIncr)
if err != nil {
return nil, err
}
table.Name = name
table.StoreEngine = engine
tables = append(tables, table)
}
return tables, nil
}
func (db *tidb) GetIndexes(tableName string) (map[string]*core.Index, error) {
args := []interface{}{db.DbName, tableName}
s := "SELECT `INDEX_NAME`, `NON_UNIQUE`, `COLUMN_NAME` FROM `INFORMATION_SCHEMA`.`STATISTICS` WHERE `TABLE_SCHEMA` = ? AND `TABLE_NAME` = ?"
rows, err := db.DB().Query(s, args...)
db.LogSQL(s, args)
if err != nil {
return nil, err
}
defer rows.Close()
indexes := make(map[string]*core.Index, 0)
for rows.Next() {
var indexType int
var indexName, colName, nonUnique string
err = rows.Scan(&indexName, &nonUnique, &colName)
if err != nil {
return nil, err
}
if indexName == "PRIMARY" {
continue
}
if "YES" == nonUnique || nonUnique == "1" {
indexType = core.IndexType
} else {
indexType = core.UniqueType
}
colName = strings.Trim(colName, "` ")
var isRegular bool
if strings.HasPrefix(indexName, "IDX_"+tableName) || strings.HasPrefix(indexName, "UQE_"+tableName) {
indexName = indexName[5+len(tableName) : len(indexName)]
isRegular = true
}
var index *core.Index
var ok bool
if index, ok = indexes[indexName]; !ok {
index = new(core.Index)
index.IsRegular = isRegular
index.Type = indexType
index.Name = indexName
indexes[indexName] = index
}
index.AddColumn(colName)
}
return indexes, nil
}
func (db *tidb) Filters() []core.Filter {
return []core.Filter{&core.IdFilter{}}
}

48
vendor/github.com/go-xorm/tidb/tidb_driver.go generated vendored
View file

@ -1,48 +0,0 @@
// Copyright 2015 The Xorm Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package tidb
import (
"errors"
"net/url"
"path/filepath"
"github.com/go-xorm/core"
)
var (
_ core.Dialect = (*tidb)(nil)
DBType core.DbType = "tidb"
)
func init() {
core.RegisterDriver(string(DBType), &tidbDriver{})
core.RegisterDialect(DBType, func() core.Dialect {
return &tidb{}
})
}
type tidbDriver struct {
}
func (p *tidbDriver) Parse(driverName, dataSourceName string) (*core.Uri, error) {
u, err := url.Parse(dataSourceName)
if err != nil {
return nil, err
}
if u.Scheme != "goleveldb" && u.Scheme != "memory" && u.Scheme != "boltdb" {
return nil, errors.New(u.Scheme + " is not supported yet.")
}
path := filepath.Join(u.Host, u.Path)
dbName := filepath.Clean(filepath.Base(path))
uri := &core.Uri{
DbType: DBType,
DbName: dbName,
}
return uri, nil
}

191
vendor/github.com/juju/errors/LICENSE generated vendored
View file

@ -1,191 +0,0 @@
All files in this repository are licensed as follows. If you contribute
to this repository, it is assumed that you license your contribution
under the same license unless you state otherwise.
All files Copyright (C) 2015 Canonical Ltd. unless otherwise specified in the file.
This software is licensed under the LGPLv3, included below.
As a special exception to the GNU Lesser General Public License version 3
("LGPL3"), the copyright holders of this Library give you permission to
convey to a third party a Combined Work that links statically or dynamically
to this Library without providing any Minimal Corresponding Source or
Minimal Application Code as set out in 4d or providing the installation
information set out in section 4e, provided that you comply with the other
provisions of LGPL3 and provided that you meet, for the Application the
terms and conditions of the license(s) which apply to the Application.
Except as stated in this special exception, the provisions of LGPL3 will
continue to comply in full to this Library. If you modify this Library, you
may apply this exception to your version of this Library, but you are not
obliged to do so. If you do not wish to do so, delete this exception
statement from your version. This exception does not (and cannot) modify any
license terms which apply to the Application, with which you must still
comply.
GNU LESSER GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
This version of the GNU Lesser General Public License incorporates
the terms and conditions of version 3 of the GNU General Public
License, supplemented by the additional permissions listed below.
0. Additional Definitions.
As used herein, "this License" refers to version 3 of the GNU Lesser
General Public License, and the "GNU GPL" refers to version 3 of the GNU
General Public License.
"The Library" refers to a covered work governed by this License,
other than an Application or a Combined Work as defined below.
An "Application" is any work that makes use of an interface provided
by the Library, but which is not otherwise based on the Library.
Defining a subclass of a class defined by the Library is deemed a mode
of using an interface provided by the Library.
A "Combined Work" is a work produced by combining or linking an
Application with the Library. The particular version of the Library
with which the Combined Work was made is also called the "Linked
Version".
The "Minimal Corresponding Source" for a Combined Work means the
Corresponding Source for the Combined Work, excluding any source code
for portions of the Combined Work that, considered in isolation, are
based on the Application, and not on the Linked Version.
The "Corresponding Application Code" for a Combined Work means the
object code and/or source code for the Application, including any data
and utility programs needed for reproducing the Combined Work from the
Application, but excluding the System Libraries of the Combined Work.
1. Exception to Section 3 of the GNU GPL.
You may convey a covered work under sections 3 and 4 of this License
without being bound by section 3 of the GNU GPL.
2. Conveying Modified Versions.
If you modify a copy of the Library, and, in your modifications, a
facility refers to a function or data to be supplied by an Application
that uses the facility (other than as an argument passed when the
facility is invoked), then you may convey a copy of the modified
version:
a) under this License, provided that you make a good faith effort to
ensure that, in the event an Application does not supply the
function or data, the facility still operates, and performs
whatever part of its purpose remains meaningful, or
b) under the GNU GPL, with none of the additional permissions of
this License applicable to that copy.
3. Object Code Incorporating Material from Library Header Files.
The object code form of an Application may incorporate material from
a header file that is part of the Library. You may convey such object
code under terms of your choice, provided that, if the incorporated
material is not limited to numerical parameters, data structure
layouts and accessors, or small macros, inline functions and templates
(ten or fewer lines in length), you do both of the following:
a) Give prominent notice with each copy of the object code that the
Library is used in it and that the Library and its use are
covered by this License.
b) Accompany the object code with a copy of the GNU GPL and this license
document.
4. Combined Works.
You may convey a Combined Work under terms of your choice that,
taken together, effectively do not restrict modification of the
portions of the Library contained in the Combined Work and reverse
engineering for debugging such modifications, if you also do each of
the following:
a) Give prominent notice with each copy of the Combined Work that
the Library is used in it and that the Library and its use are
covered by this License.
b) Accompany the Combined Work with a copy of the GNU GPL and this license
document.
c) For a Combined Work that displays copyright notices during
execution, include the copyright notice for the Library among
these notices, as well as a reference directing the user to the
copies of the GNU GPL and this license document.
d) Do one of the following:
0) Convey the Minimal Corresponding Source under the terms of this
License, and the Corresponding Application Code in a form
suitable for, and under terms that permit, the user to
recombine or relink the Application with a modified version of
the Linked Version to produce a modified Combined Work, in the
manner specified by section 6 of the GNU GPL for conveying
Corresponding Source.
1) Use a suitable shared library mechanism for linking with the
Library. A suitable mechanism is one that (a) uses at run time
a copy of the Library already present on the user's computer
system, and (b) will operate properly with a modified version
of the Library that is interface-compatible with the Linked
Version.
e) Provide Installation Information, but only if you would otherwise
be required to provide such information under section 6 of the
GNU GPL, and only to the extent that such information is
necessary to install and execute a modified version of the
Combined Work produced by recombining or relinking the
Application with a modified version of the Linked Version. (If
you use option 4d0, the Installation Information must accompany
the Minimal Corresponding Source and Corresponding Application
Code. If you use option 4d1, you must provide the Installation
Information in the manner specified by section 6 of the GNU GPL
for conveying Corresponding Source.)
5. Combined Libraries.
You may place library facilities that are a work based on the
Library side by side in a single library together with other library
facilities that are not Applications and are not covered by this
License, and convey such a combined library under terms of your
choice, if you do both of the following:
a) Accompany the combined library with a copy of the same work based
on the Library, uncombined with any other library facilities,
conveyed under the terms of this License.
b) Give prominent notice with the combined library that part of it
is a work based on the Library, and explaining where to find the
accompanying uncombined form of the same work.
6. Revised Versions of the GNU Lesser General Public License.
The Free Software Foundation may publish revised and/or new versions
of the GNU Lesser General Public License from time to time. Such new
versions will be similar in spirit to the present version, but may
differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the
Library as you received it specifies that a certain numbered version
of the GNU Lesser General Public License "or any later version"
applies to it, you have the option of following the terms and
conditions either of that published version or of any later version
published by the Free Software Foundation. If the Library as you
received it does not specify a version number of the GNU Lesser
General Public License, you may choose any version of the GNU Lesser
General Public License ever published by the Free Software Foundation.
If the Library as you received it specifies that a proxy can decide
whether future versions of the GNU Lesser General Public License shall
apply, that proxy's public statement of acceptance of any version is
permanent authorization for you to choose that version for the
Library.

81
vendor/github.com/juju/errors/doc.go generated vendored
View file

@ -1,81 +0,0 @@
// Copyright 2013, 2014 Canonical Ltd.
// Licensed under the LGPLv3, see LICENCE file for details.
/*
[godoc-link-here]
The juju/errors provides an easy way to annotate errors without losing the
orginal error context.
The exported `New` and `Errorf` functions are designed to replace the
`errors.New` and `fmt.Errorf` functions respectively. The same underlying
error is there, but the package also records the location at which the error
was created.
A primary use case for this library is to add extra context any time an
error is returned from a function.
if err := SomeFunc(); err != nil {
return err
}
This instead becomes:
if err := SomeFunc(); err != nil {
return errors.Trace(err)
}
which just records the file and line number of the Trace call, or
if err := SomeFunc(); err != nil {
return errors.Annotate(err, "more context")
}
which also adds an annotation to the error.
When you want to check to see if an error is of a particular type, a helper
function is normally exported by the package that returned the error, like the
`os` package does. The underlying cause of the error is available using the
`Cause` function.
os.IsNotExist(errors.Cause(err))
The result of the `Error()` call on an annotated error is the annotations joined
with colons, then the result of the `Error()` method for the underlying error
that was the cause.
err := errors.Errorf("original")
err = errors.Annotatef(err, "context")
err = errors.Annotatef(err, "more context")
err.Error() -> "more context: context: original"
Obviously recording the file, line and functions is not very useful if you
cannot get them back out again.
errors.ErrorStack(err)
will return something like:
first error
github.com/juju/errors/annotation_test.go:193:
github.com/juju/errors/annotation_test.go:194: annotation
github.com/juju/errors/annotation_test.go:195:
github.com/juju/errors/annotation_test.go:196: more context
github.com/juju/errors/annotation_test.go:197:
The first error was generated by an external system, so there was no location
associated. The second, fourth, and last lines were generated with Trace calls,
and the other two through Annotate.
Sometimes when responding to an error you want to return a more specific error
for the situation.
if err := FindField(field); err != nil {
return errors.Wrap(err, errors.NotFoundf(field))
}
This returns an error where the complete error stack is still available, and
`errors.Cause()` will return the `NotFound` error.
*/
package errors

145
vendor/github.com/juju/errors/error.go generated vendored
View file

@ -1,145 +0,0 @@
// Copyright 2014 Canonical Ltd.
// Licensed under the LGPLv3, see LICENCE file for details.
package errors
import (
"fmt"
"reflect"
"runtime"
)
// Err holds a description of an error along with information about
// where the error was created.
//
// It may be embedded in custom error types to add extra information that
// this errors package can understand.
type Err struct {
// message holds an annotation of the error.
message string
// cause holds the cause of the error as returned
// by the Cause method.
cause error
// previous holds the previous error in the error stack, if any.
previous error
// file and line hold the source code location where the error was
// created.
file string
line int
}
// NewErr is used to return an Err for the purpose of embedding in other
// structures. The location is not specified, and needs to be set with a call
// to SetLocation.
//
// For example:
// type FooError struct {
// errors.Err
// code int
// }
//
// func NewFooError(code int) error {
// err := &FooError{errors.NewErr("foo"), code}
// err.SetLocation(1)
// return err
// }
func NewErr(format string, args ...interface{}) Err {
return Err{
message: fmt.Sprintf(format, args...),
}
}
// NewErrWithCause is used to return an Err with case by other error for the purpose of embedding in other
// structures. The location is not specified, and needs to be set with a call
// to SetLocation.
//
// For example:
// type FooError struct {
// errors.Err
// code int
// }
//
// func (e *FooError) Annotate(format string, args ...interface{}) error {
// err := &FooError{errors.NewErrWithCause(e.Err, format, args...), e.code}
// err.SetLocation(1)
// return err
// })
func NewErrWithCause(other error, format string, args ...interface{}) Err {
return Err{
message: fmt.Sprintf(format, args...),
cause: Cause(other),
previous: other,
}
}
// Location is the file and line of where the error was most recently
// created or annotated.
func (e *Err) Location() (filename string, line int) {
return e.file, e.line
}
// Underlying returns the previous error in the error stack, if any. A client
// should not ever really call this method. It is used to build the error
// stack and should not be introspected by client calls. Or more
// specifically, clients should not depend on anything but the `Cause` of an
// error.
func (e *Err) Underlying() error {
return e.previous
}
// The Cause of an error is the most recent error in the error stack that
// meets one of these criteria: the original error that was raised; the new
// error that was passed into the Wrap function; the most recently masked
// error; or nil if the error itself is considered the Cause. Normally this
// method is not invoked directly, but instead through the Cause stand alone
// function.
func (e *Err) Cause() error {
return e.cause
}
// Message returns the message stored with the most recent location. This is
// the empty string if the most recent call was Trace, or the message stored
// with Annotate or Mask.
func (e *Err) Message() string {
return e.message
}
// Error implements error.Error.
func (e *Err) Error() string {
// We want to walk up the stack of errors showing the annotations
// as long as the cause is the same.
err := e.previous
if !sameError(Cause(err), e.cause) && e.cause != nil {
err = e.cause
}
switch {
case err == nil:
return e.message
case e.message == "":
return err.Error()
}
return fmt.Sprintf("%s: %v", e.message, err)
}
// SetLocation records the source location of the error at callDepth stack
// frames above the call.
func (e *Err) SetLocation(callDepth int) {
_, file, line, _ := runtime.Caller(callDepth + 1)
e.file = trimGoPath(file)
e.line = line
}
// StackTrace returns one string for each location recorded in the stack of
// errors. The first value is the originating error, with a line for each
// other annotation or tracing of the error.
func (e *Err) StackTrace() []string {
return errorStack(e)
}
// Ideally we'd have a way to check identity, but deep equals will do.
func sameError(e1, e2 error) bool {
return reflect.DeepEqual(e1, e2)
}

284
vendor/github.com/juju/errors/errortypes.go generated vendored
View file

@ -1,284 +0,0 @@
// Copyright 2014 Canonical Ltd.
// Licensed under the LGPLv3, see LICENCE file for details.
package errors
import (
"fmt"
)
// wrap is a helper to construct an *wrapper.
func wrap(err error, format, suffix string, args ...interface{}) Err {
newErr := Err{
message: fmt.Sprintf(format+suffix, args...),
previous: err,
}
newErr.SetLocation(2)
return newErr
}
// notFound represents an error when something has not been found.
type notFound struct {
Err
}
// NotFoundf returns an error which satisfies IsNotFound().
func NotFoundf(format string, args ...interface{}) error {
return &notFound{wrap(nil, format, " not found", args...)}
}
// NewNotFound returns an error which wraps err that satisfies
// IsNotFound().
func NewNotFound(err error, msg string) error {
return &notFound{wrap(err, msg, "")}
}
// IsNotFound reports whether err was created with NotFoundf() or
// NewNotFound().
func IsNotFound(err error) bool {
err = Cause(err)
_, ok := err.(*notFound)
return ok
}
// userNotFound represents an error when an inexistent user is looked up.
type userNotFound struct {
Err
}
// UserNotFoundf returns an error which satisfies IsUserNotFound().
func UserNotFoundf(format string, args ...interface{}) error {
return &userNotFound{wrap(nil, format, " user not found", args...)}
}
// NewUserNotFound returns an error which wraps err and satisfies
// IsUserNotFound().
func NewUserNotFound(err error, msg string) error {
return &userNotFound{wrap(err, msg, "")}
}
// IsUserNotFound reports whether err was created with UserNotFoundf() or
// NewUserNotFound().
func IsUserNotFound(err error) bool {
err = Cause(err)
_, ok := err.(*userNotFound)
return ok
}
// unauthorized represents an error when an operation is unauthorized.
type unauthorized struct {
Err
}
// Unauthorizedf returns an error which satisfies IsUnauthorized().
func Unauthorizedf(format string, args ...interface{}) error {
return &unauthorized{wrap(nil, format, "", args...)}
}
// NewUnauthorized returns an error which wraps err and satisfies
// IsUnauthorized().
func NewUnauthorized(err error, msg string) error {
return &unauthorized{wrap(err, msg, "")}
}
// IsUnauthorized reports whether err was created with Unauthorizedf() or
// NewUnauthorized().
func IsUnauthorized(err error) bool {
err = Cause(err)
_, ok := err.(*unauthorized)
return ok
}
// notImplemented represents an error when something is not
// implemented.
type notImplemented struct {
Err
}
// NotImplementedf returns an error which satisfies IsNotImplemented().
func NotImplementedf(format string, args ...interface{}) error {
return &notImplemented{wrap(nil, format, " not implemented", args...)}
}
// NewNotImplemented returns an error which wraps err and satisfies
// IsNotImplemented().
func NewNotImplemented(err error, msg string) error {
return &notImplemented{wrap(err, msg, "")}
}
// IsNotImplemented reports whether err was created with
// NotImplementedf() or NewNotImplemented().
func IsNotImplemented(err error) bool {
err = Cause(err)
_, ok := err.(*notImplemented)
return ok
}
// alreadyExists represents and error when something already exists.
type alreadyExists struct {
Err
}
// AlreadyExistsf returns an error which satisfies IsAlreadyExists().
func AlreadyExistsf(format string, args ...interface{}) error {
return &alreadyExists{wrap(nil, format, " already exists", args...)}
}
// NewAlreadyExists returns an error which wraps err and satisfies
// IsAlreadyExists().
func NewAlreadyExists(err error, msg string) error {
return &alreadyExists{wrap(err, msg, "")}
}
// IsAlreadyExists reports whether the error was created with
// AlreadyExistsf() or NewAlreadyExists().
func IsAlreadyExists(err error) bool {
err = Cause(err)
_, ok := err.(*alreadyExists)
return ok
}
// notSupported represents an error when something is not supported.
type notSupported struct {
Err
}
// NotSupportedf returns an error which satisfies IsNotSupported().
func NotSupportedf(format string, args ...interface{}) error {
return &notSupported{wrap(nil, format, " not supported", args...)}
}
// NewNotSupported returns an error which wraps err and satisfies
// IsNotSupported().
func NewNotSupported(err error, msg string) error {
return &notSupported{wrap(err, msg, "")}
}
// IsNotSupported reports whether the error was created with
// NotSupportedf() or NewNotSupported().
func IsNotSupported(err error) bool {
err = Cause(err)
_, ok := err.(*notSupported)
return ok
}
// notValid represents an error when something is not valid.
type notValid struct {
Err
}
// NotValidf returns an error which satisfies IsNotValid().
func NotValidf(format string, args ...interface{}) error {
return &notValid{wrap(nil, format, " not valid", args...)}
}
// NewNotValid returns an error which wraps err and satisfies IsNotValid().
func NewNotValid(err error, msg string) error {
return &notValid{wrap(err, msg, "")}
}
// IsNotValid reports whether the error was created with NotValidf() or
// NewNotValid().
func IsNotValid(err error) bool {
err = Cause(err)
_, ok := err.(*notValid)
return ok
}
// notProvisioned represents an error when something is not yet provisioned.
type notProvisioned struct {
Err
}
// NotProvisionedf returns an error which satisfies IsNotProvisioned().
func NotProvisionedf(format string, args ...interface{}) error {
return &notProvisioned{wrap(nil, format, " not provisioned", args...)}
}
// NewNotProvisioned returns an error which wraps err that satisfies
// IsNotProvisioned().
func NewNotProvisioned(err error, msg string) error {
return &notProvisioned{wrap(err, msg, "")}
}
// IsNotProvisioned reports whether err was created with NotProvisionedf() or
// NewNotProvisioned().
func IsNotProvisioned(err error) bool {
err = Cause(err)
_, ok := err.(*notProvisioned)
return ok
}
// notAssigned represents an error when something is not yet assigned to
// something else.
type notAssigned struct {
Err
}
// NotAssignedf returns an error which satisfies IsNotAssigned().
func NotAssignedf(format string, args ...interface{}) error {
return &notAssigned{wrap(nil, format, " not assigned", args...)}
}
// NewNotAssigned returns an error which wraps err that satisfies
// IsNotAssigned().
func NewNotAssigned(err error, msg string) error {
return &notAssigned{wrap(err, msg, "")}
}
// IsNotAssigned reports whether err was created with NotAssignedf() or
// NewNotAssigned().
func IsNotAssigned(err error) bool {
err = Cause(err)
_, ok := err.(*notAssigned)
return ok
}
// badRequest represents an error when a request has bad parameters.
type badRequest struct {
Err
}
// BadRequestf returns an error which satisfies IsBadRequest().
func BadRequestf(format string, args ...interface{}) error {
return &badRequest{wrap(nil, format, "", args...)}
}
// NewBadRequest returns an error which wraps err that satisfies
// IsBadRequest().
func NewBadRequest(err error, msg string) error {
return &badRequest{wrap(err, msg, "")}
}
// IsBadRequest reports whether err was created with BadRequestf() or
// NewBadRequest().
func IsBadRequest(err error) bool {
err = Cause(err)
_, ok := err.(*badRequest)
return ok
}
// methodNotAllowed represents an error when an HTTP request
// is made with an inappropriate method.
type methodNotAllowed struct {
Err
}
// MethodNotAllowedf returns an error which satisfies IsMethodNotAllowed().
func MethodNotAllowedf(format string, args ...interface{}) error {
return &methodNotAllowed{wrap(nil, format, "", args...)}
}
// NewMethodNotAllowed returns an error which wraps err that satisfies
// IsMethodNotAllowed().
func NewMethodNotAllowed(err error, msg string) error {
return &methodNotAllowed{wrap(err, msg, "")}
}
// IsMethodNotAllowed reports whether err was created with MethodNotAllowedf() or
// NewMethodNotAllowed().
func IsMethodNotAllowed(err error) bool {
err = Cause(err)
_, ok := err.(*methodNotAllowed)
return ok
}

330
vendor/github.com/juju/errors/functions.go generated vendored
View file

@ -1,330 +0,0 @@
// Copyright 2014 Canonical Ltd.
// Licensed under the LGPLv3, see LICENCE file for details.
package errors
import (
"fmt"
"strings"
)
// New is a drop in replacement for the standard libary errors module that records
// the location that the error is created.
//
// For example:
// return errors.New("validation failed")
//
func New(message string) error {
err := &Err{message: message}
err.SetLocation(1)
return err
}
// Errorf creates a new annotated error and records the location that the
// error is created. This should be a drop in replacement for fmt.Errorf.
//
// For example:
// return errors.Errorf("validation failed: %s", message)
//
func Errorf(format string, args ...interface{}) error {
err := &Err{message: fmt.Sprintf(format, args...)}
err.SetLocation(1)
return err
}
// Trace adds the location of the Trace call to the stack. The Cause of the
// resulting error is the same as the error parameter. If the other error is
// nil, the result will be nil.
//
// For example:
// if err := SomeFunc(); err != nil {
// return errors.Trace(err)
// }
//
func Trace(other error) error {
if other == nil {
return nil
}
err := &Err{previous: other, cause: Cause(other)}
err.SetLocation(1)
return err
}
// Annotate is used to add extra context to an existing error. The location of
// the Annotate call is recorded with the annotations. The file, line and
// function are also recorded.
//
// For example:
// if err := SomeFunc(); err != nil {
// return errors.Annotate(err, "failed to frombulate")
// }
//
func Annotate(other error, message string) error {
if other == nil {
return nil
}
err := &Err{
previous: other,
cause: Cause(other),
message: message,
}
err.SetLocation(1)
return err
}
// Annotatef is used to add extra context to an existing error. The location of
// the Annotate call is recorded with the annotations. The file, line and
// function are also recorded.
//
// For example:
// if err := SomeFunc(); err != nil {
// return errors.Annotatef(err, "failed to frombulate the %s", arg)
// }
//
func Annotatef(other error, format string, args ...interface{}) error {
if other == nil {
return nil
}
err := &Err{
previous: other,
cause: Cause(other),
message: fmt.Sprintf(format, args...),
}
err.SetLocation(1)
return err
}
// DeferredAnnotatef annotates the given error (when it is not nil) with the given
// format string and arguments (like fmt.Sprintf). If *err is nil, DeferredAnnotatef
// does nothing. This method is used in a defer statement in order to annotate any
// resulting error with the same message.
//
// For example:
//
// defer DeferredAnnotatef(&err, "failed to frombulate the %s", arg)
//
func DeferredAnnotatef(err *error, format string, args ...interface{}) {
if *err == nil {
return
}
newErr := &Err{
message: fmt.Sprintf(format, args...),
cause: Cause(*err),
previous: *err,
}
newErr.SetLocation(1)
*err = newErr
}
// Wrap changes the Cause of the error. The location of the Wrap call is also
// stored in the error stack.
//
// For example:
// if err := SomeFunc(); err != nil {
// newErr := &packageError{"more context", private_value}
// return errors.Wrap(err, newErr)
// }
//
func Wrap(other, newDescriptive error) error {
err := &Err{
previous: other,
cause: newDescriptive,
}
err.SetLocation(1)
return err
}
// Wrapf changes the Cause of the error, and adds an annotation. The location
// of the Wrap call is also stored in the error stack.
//
// For example:
// if err := SomeFunc(); err != nil {
// return errors.Wrapf(err, simpleErrorType, "invalid value %q", value)
// }
//
func Wrapf(other, newDescriptive error, format string, args ...interface{}) error {
err := &Err{
message: fmt.Sprintf(format, args...),
previous: other,
cause: newDescriptive,
}
err.SetLocation(1)
return err
}
// Mask masks the given error with the given format string and arguments (like
// fmt.Sprintf), returning a new error that maintains the error stack, but
// hides the underlying error type. The error string still contains the full
// annotations. If you want to hide the annotations, call Wrap.
func Maskf(other error, format string, args ...interface{}) error {
if other == nil {
return nil
}
err := &Err{
message: fmt.Sprintf(format, args...),
previous: other,
}
err.SetLocation(1)
return err
}
// Mask hides the underlying error type, and records the location of the masking.
func Mask(other error) error {
if other == nil {
return nil
}
err := &Err{
previous: other,
}
err.SetLocation(1)
return err
}
// Cause returns the cause of the given error. This will be either the
// original error, or the result of a Wrap or Mask call.
//
// Cause is the usual way to diagnose errors that may have been wrapped by
// the other errors functions.
func Cause(err error) error {
var diag error
if err, ok := err.(causer); ok {
diag = err.Cause()
}
if diag != nil {
return diag
}
return err
}
type causer interface {
Cause() error
}
type wrapper interface {
// Message returns the top level error message,
// not including the message from the Previous
// error.
Message() string
// Underlying returns the Previous error, or nil
// if there is none.
Underlying() error
}
type locationer interface {
Location() (string, int)
}
var (
_ wrapper = (*Err)(nil)
_ locationer = (*Err)(nil)
_ causer = (*Err)(nil)
)
// Details returns information about the stack of errors wrapped by err, in
// the format:
//
// [{filename:99: error one} {otherfile:55: cause of error one}]
//
// This is a terse alternative to ErrorStack as it returns a single line.
func Details(err error) string {
if err == nil {
return "[]"
}
var s []byte
s = append(s, '[')
for {
s = append(s, '{')
if err, ok := err.(locationer); ok {
file, line := err.Location()
if file != "" {
s = append(s, fmt.Sprintf("%s:%d", file, line)...)
s = append(s, ": "...)
}
}
if cerr, ok := err.(wrapper); ok {
s = append(s, cerr.Message()...)
err = cerr.Underlying()
} else {
s = append(s, err.Error()...)
err = nil
}
s = append(s, '}')
if err == nil {
break
}
s = append(s, ' ')
}
s = append(s, ']')
return string(s)
}
// ErrorStack returns a string representation of the annotated error. If the
// error passed as the parameter is not an annotated error, the result is
// simply the result of the Error() method on that error.
//
// If the error is an annotated error, a multi-line string is returned where
// each line represents one entry in the annotation stack. The full filename
// from the call stack is used in the output.
//
// first error
// github.com/juju/errors/annotation_test.go:193:
// github.com/juju/errors/annotation_test.go:194: annotation
// github.com/juju/errors/annotation_test.go:195:
// github.com/juju/errors/annotation_test.go:196: more context
// github.com/juju/errors/annotation_test.go:197:
func ErrorStack(err error) string {
return strings.Join(errorStack(err), "\n")
}
func errorStack(err error) []string {
if err == nil {
return nil
}
// We want the first error first
var lines []string
for {
var buff []byte
if err, ok := err.(locationer); ok {
file, line := err.Location()
// Strip off the leading GOPATH/src path elements.
file = trimGoPath(file)
if file != "" {
buff = append(buff, fmt.Sprintf("%s:%d", file, line)...)
buff = append(buff, ": "...)
}
}
if cerr, ok := err.(wrapper); ok {
message := cerr.Message()
buff = append(buff, message...)
// If there is a cause for this error, and it is different to the cause
// of the underlying error, then output the error string in the stack trace.
var cause error
if err1, ok := err.(causer); ok {
cause = err1.Cause()
}
err = cerr.Underlying()
if cause != nil && !sameError(Cause(err), cause) {
if message != "" {
buff = append(buff, ": "...)
}
buff = append(buff, cause.Error()...)
}
} else {
buff = append(buff, err.Error()...)
err = nil
}
lines = append(lines, string(buff))
if err == nil {
break
}
}
// reverse the lines to get the original error, which was at the end of
// the list, back to the start.
var result []string
for i := len(lines); i > 0; i-- {
result = append(result, lines[i-1])
}
return result
}

38
vendor/github.com/juju/errors/path.go generated vendored
View file

@ -1,38 +0,0 @@
// Copyright 2013, 2014 Canonical Ltd.
// Licensed under the LGPLv3, see LICENCE file for details.
package errors
import (
"runtime"
"strings"
)
// prefixSize is used internally to trim the user specific path from the
// front of the returned filenames from the runtime call stack.
var prefixSize int
// goPath is the deduced path based on the location of this file as compiled.
var goPath string
func init() {
_, file, _, ok := runtime.Caller(0)
if file == "?" {
return
}
if ok {
// We know that the end of the file should be:
// github.com/juju/errors/path.go
size := len(file)
suffix := len("github.com/juju/errors/path.go")
goPath = file[:size-suffix]
prefixSize = len(goPath)
}
}
func trimGoPath(filename string) string {
if strings.HasPrefix(filename, goPath) {
return filename[prefixSize:]
}
return filename
}

50
vendor/github.com/ngaut/deadline/rw.go generated vendored
View file

@ -1,50 +0,0 @@
package deadline
import (
"io"
"time"
)
type DeadlineReader interface {
io.Reader
SetReadDeadline(t time.Time) error
}
type DeadlineWriter interface {
io.Writer
SetWriteDeadline(t time.Time) error
}
type DeadlineReadWriter interface {
io.ReadWriter
SetReadDeadline(t time.Time) error
SetWriteDeadline(t time.Time) error
}
type deadlineReader struct {
DeadlineReader
timeout time.Duration
}
func (r *deadlineReader) Read(p []byte) (int, error) {
r.DeadlineReader.SetReadDeadline(time.Now().Add(r.timeout))
return r.DeadlineReader.Read(p)
}
func NewDeadlineReader(r DeadlineReader, timeout time.Duration) io.Reader {
return &deadlineReader{DeadlineReader: r, timeout: timeout}
}
type deadlineWriter struct {
DeadlineWriter
timeout time.Duration
}
func (r *deadlineWriter) Write(p []byte) (int, error) {
r.DeadlineWriter.SetWriteDeadline(time.Now().Add(r.timeout))
return r.DeadlineWriter.Write(p)
}
func NewDeadlineWriter(r DeadlineWriter, timeout time.Duration) io.Writer {
return &deadlineWriter{DeadlineWriter: r, timeout: timeout}
}

25
vendor/github.com/ngaut/go-zookeeper/LICENSE generated vendored
View file

@ -1,25 +0,0 @@
Copyright (c) 2013, Samuel Stauffer <samuel@descolada.com>
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the author nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

788
vendor/github.com/ngaut/go-zookeeper/zk/conn.go generated vendored
View file

@ -1,788 +0,0 @@
package zk
/*
TODO:
* make sure a ping response comes back in a reasonable time
Possible watcher events:
* Event{Type: EventNotWatching, State: StateDisconnected, Path: path, Err: err}
*/
import (
"crypto/rand"
"encoding/binary"
"errors"
"fmt"
"io"
"log"
"net"
"strconv"
"strings"
"sync"
"sync/atomic"
"time"
)
var ErrNoServer = errors.New("zk: could not connect to a server")
const (
bufferSize = 10 * 1024 * 1024
eventChanSize = 6
sendChanSize = 16
protectedPrefix = "_c_"
)
type watchType int
const (
watchTypeData = iota
watchTypeExist = iota
watchTypeChild = iota
)
type watchPathType struct {
path string
wType watchType
}
type Dialer func(network, address string, timeout time.Duration) (net.Conn, error)
type Conn struct {
lastZxid int64
sessionID int64
state State // must be 32-bit aligned
xid int32
timeout int32 // session timeout in seconds
passwd []byte
dialer Dialer
servers []string
serverIndex int
conn net.Conn
eventChan chan Event
shouldQuit chan bool
pingInterval time.Duration
recvTimeout time.Duration
connectTimeout time.Duration
sendChan chan *request
requests map[int32]*request // Xid -> pending request
requestsLock sync.Mutex
watchers map[watchPathType][]chan Event
watchersLock sync.Mutex
// Debug (used by unit tests)
reconnectDelay time.Duration
}
type request struct {
xid int32
opcode int32
pkt interface{}
recvStruct interface{}
recvChan chan response
// Because sending and receiving happen in separate go routines, there's
// a possible race condition when creating watches from outside the read
// loop. We must ensure that a watcher gets added to the list synchronously
// with the response from the server on any request that creates a watch.
// In order to not hard code the watch logic for each opcode in the recv
// loop the caller can use recvFunc to insert some synchronously code
// after a response.
recvFunc func(*request, *responseHeader, error)
}
type response struct {
zxid int64
err error
}
type Event struct {
Type EventType
State State
Path string // For non-session events, the path of the watched node.
Err error
}
func Connect(servers []string, recvTimeout time.Duration) (*Conn, <-chan Event, error) {
return ConnectWithDialer(servers, recvTimeout, nil)
}
func ConnectWithDialer(servers []string, recvTimeout time.Duration, dialer Dialer) (*Conn, <-chan Event, error) {
// Randomize the order of the servers to avoid creating hotspots
stringShuffle(servers)
for i, addr := range servers {
if !strings.Contains(addr, ":") {
servers[i] = addr + ":" + strconv.Itoa(DefaultPort)
}
}
ec := make(chan Event, eventChanSize)
if dialer == nil {
dialer = net.DialTimeout
}
conn := Conn{
dialer: dialer,
servers: servers,
serverIndex: 0,
conn: nil,
state: StateDisconnected,
eventChan: ec,
shouldQuit: make(chan bool),
recvTimeout: recvTimeout,
pingInterval: time.Duration((int64(recvTimeout) / 2)),
connectTimeout: 1 * time.Second,
sendChan: make(chan *request, sendChanSize),
requests: make(map[int32]*request),
watchers: make(map[watchPathType][]chan Event),
passwd: emptyPassword,
timeout: 30000,
// Debug
reconnectDelay: time.Second,
}
go func() {
conn.loop()
conn.flushRequests(ErrClosing)
conn.invalidateWatches(ErrClosing)
close(conn.eventChan)
}()
return &conn, ec, nil
}
func (c *Conn) Close() {
close(c.shouldQuit)
select {
case <-c.queueRequest(opClose, &closeRequest{}, &closeResponse{}, nil):
case <-time.After(time.Second):
}
}
func (c *Conn) State() State {
return State(atomic.LoadInt32((*int32)(&c.state)))
}
func (c *Conn) setState(state State) {
atomic.StoreInt32((*int32)(&c.state), int32(state))
select {
case c.eventChan <- Event{Type: EventSession, State: state}:
default:
// panic("zk: event channel full - it must be monitored and never allowed to be full")
}
}
func (c *Conn) connect() {
c.serverIndex = (c.serverIndex + 1) % len(c.servers)
startIndex := c.serverIndex
c.setState(StateConnecting)
for {
zkConn, err := c.dialer("tcp", c.servers[c.serverIndex], c.connectTimeout)
if err == nil {
c.conn = zkConn
c.setState(StateConnected)
return
}
log.Printf("Failed to connect to %s: %+v", c.servers[c.serverIndex], err)
c.serverIndex = (c.serverIndex + 1) % len(c.servers)
if c.serverIndex == startIndex {
c.flushUnsentRequests(ErrNoServer)
time.Sleep(time.Second)
}
}
}
func (c *Conn) loop() {
for {
c.connect()
err := c.authenticate()
switch {
case err == ErrSessionExpired:
c.invalidateWatches(err)
case err != nil && c.conn != nil:
c.conn.Close()
case err == nil:
closeChan := make(chan bool) // channel to tell send loop stop
var wg sync.WaitGroup
wg.Add(1)
go func() {
c.sendLoop(c.conn, closeChan)
c.conn.Close() // causes recv loop to EOF/exit
wg.Done()
}()
wg.Add(1)
go func() {
err = c.recvLoop(c.conn)
if err == nil {
panic("zk: recvLoop should never return nil error")
}
close(closeChan) // tell send loop to exit
wg.Done()
}()
wg.Wait()
}
c.setState(StateDisconnected)
// Yeesh
if err != io.EOF && err != ErrSessionExpired && !strings.Contains(err.Error(), "use of closed network connection") {
log.Println(err)
}
select {
case <-c.shouldQuit:
c.flushRequests(ErrClosing)
return
default:
}
if err != ErrSessionExpired {
err = ErrConnectionClosed
}
c.flushRequests(err)
if c.reconnectDelay > 0 {
select {
case <-c.shouldQuit:
return
case <-time.After(c.reconnectDelay):
}
}
}
}
func (c *Conn) flushUnsentRequests(err error) {
for {
select {
default:
return
case req := <-c.sendChan:
req.recvChan <- response{-1, err}
}
}
}
// Send error to all pending requests and clear request map
func (c *Conn) flushRequests(err error) {
c.requestsLock.Lock()
for _, req := range c.requests {
req.recvChan <- response{-1, err}
}
c.requests = make(map[int32]*request)
c.requestsLock.Unlock()
}
// Send error to all watchers and clear watchers map
func (c *Conn) invalidateWatches(err error) {
c.watchersLock.Lock()
defer c.watchersLock.Unlock()
if len(c.watchers) >= 0 {
for pathType, watchers := range c.watchers {
ev := Event{Type: EventNotWatching, State: StateDisconnected, Path: pathType.path, Err: err}
for _, ch := range watchers {
ch <- ev
close(ch)
}
}
c.watchers = make(map[watchPathType][]chan Event)
}
}
func (c *Conn) sendSetWatches() {
c.watchersLock.Lock()
defer c.watchersLock.Unlock()
if len(c.watchers) == 0 {
return
}
req := &setWatchesRequest{
RelativeZxid: c.lastZxid,
DataWatches: make([]string, 0),
ExistWatches: make([]string, 0),
ChildWatches: make([]string, 0),
}
n := 0
for pathType, watchers := range c.watchers {
if len(watchers) == 0 {
continue
}
switch pathType.wType {
case watchTypeData:
req.DataWatches = append(req.DataWatches, pathType.path)
case watchTypeExist:
req.ExistWatches = append(req.ExistWatches, pathType.path)
case watchTypeChild:
req.ChildWatches = append(req.ChildWatches, pathType.path)
}
n++
}
if n == 0 {
return
}
go func() {
res := &setWatchesResponse{}
_, err := c.request(opSetWatches, req, res, nil)
if err != nil {
log.Printf("Failed to set previous watches: %s", err.Error())
}
}()
}
func (c *Conn) authenticate() error {
buf := make([]byte, 256)
// connect request
n, err := encodePacket(buf[4:], &connectRequest{
ProtocolVersion: protocolVersion,
LastZxidSeen: c.lastZxid,
TimeOut: c.timeout,
SessionID: c.sessionID,
Passwd: c.passwd,
})
if err != nil {
return err
}
binary.BigEndian.PutUint32(buf[:4], uint32(n))
_, err = c.conn.Write(buf[:n+4])
if err != nil {
return err
}
c.sendSetWatches()
// connect response
// package length
_, err = io.ReadFull(c.conn, buf[:4])
if err != nil {
return err
}
blen := int(binary.BigEndian.Uint32(buf[:4]))
if cap(buf) < blen {
buf = make([]byte, blen)
}
_, err = io.ReadFull(c.conn, buf[:blen])
if err != nil {
return err
}
r := connectResponse{}
_, err = decodePacket(buf[:blen], &r)
if err != nil {
return err
}
if r.SessionID == 0 {
c.sessionID = 0
c.passwd = emptyPassword
c.lastZxid = 0
c.setState(StateExpired)
return ErrSessionExpired
}
if c.sessionID != r.SessionID {
atomic.StoreInt32(&c.xid, 0)
}
c.timeout = r.TimeOut
c.sessionID = r.SessionID
c.passwd = r.Passwd
c.setState(StateHasSession)
return nil
}
func (c *Conn) sendLoop(conn net.Conn, closeChan <-chan bool) error {
pingTicker := time.NewTicker(c.pingInterval)
defer pingTicker.Stop()
buf := make([]byte, bufferSize)
for {
select {
case req := <-c.sendChan:
header := &requestHeader{req.xid, req.opcode}
n, err := encodePacket(buf[4:], header)
if err != nil {
req.recvChan <- response{-1, err}
continue
}
n2, err := encodePacket(buf[4+n:], req.pkt)
if err != nil {
req.recvChan <- response{-1, err}
continue
}
n += n2
binary.BigEndian.PutUint32(buf[:4], uint32(n))
c.requestsLock.Lock()
select {
case <-closeChan:
req.recvChan <- response{-1, ErrConnectionClosed}
c.requestsLock.Unlock()
return ErrConnectionClosed
default:
}
c.requests[req.xid] = req
c.requestsLock.Unlock()
conn.SetWriteDeadline(time.Now().Add(c.recvTimeout))
_, err = conn.Write(buf[:n+4])
conn.SetWriteDeadline(time.Time{})
if err != nil {
req.recvChan <- response{-1, err}
conn.Close()
return err
}
case <-pingTicker.C:
n, err := encodePacket(buf[4:], &requestHeader{Xid: -2, Opcode: opPing})
if err != nil {
panic("zk: opPing should never fail to serialize")
}
binary.BigEndian.PutUint32(buf[:4], uint32(n))
conn.SetWriteDeadline(time.Now().Add(c.recvTimeout))
_, err = conn.Write(buf[:n+4])
conn.SetWriteDeadline(time.Time{})
if err != nil {
conn.Close()
return err
}
case <-closeChan:
return nil
}
}
}
func (c *Conn) recvLoop(conn net.Conn) error {
buf := make([]byte, bufferSize)
for {
// package length
conn.SetReadDeadline(time.Now().Add(c.recvTimeout))
_, err := io.ReadFull(conn, buf[:4])
if err != nil {
return err
}
blen := int(binary.BigEndian.Uint32(buf[:4]))
if cap(buf) < blen {
buf = make([]byte, blen)
}
_, err = io.ReadFull(conn, buf[:blen])
conn.SetReadDeadline(time.Time{})
if err != nil {
return err
}
res := responseHeader{}
_, err = decodePacket(buf[:16], &res)
if err != nil {
return err
}
if res.Xid == -1 {
res := &watcherEvent{}
_, err := decodePacket(buf[16:16+blen], res)
if err != nil {
return err
}
ev := Event{
Type: res.Type,
State: res.State,
Path: res.Path,
Err: nil,
}
select {
case c.eventChan <- ev:
default:
}
wTypes := make([]watchType, 0, 2)
switch res.Type {
case EventNodeCreated:
wTypes = append(wTypes, watchTypeExist)
case EventNodeDeleted, EventNodeDataChanged:
wTypes = append(wTypes, watchTypeExist, watchTypeData, watchTypeChild)
case EventNodeChildrenChanged:
wTypes = append(wTypes, watchTypeChild)
}
c.watchersLock.Lock()
for _, t := range wTypes {
wpt := watchPathType{res.Path, t}
if watchers := c.watchers[wpt]; watchers != nil && len(watchers) > 0 {
for _, ch := range watchers {
ch <- ev
close(ch)
}
delete(c.watchers, wpt)
}
}
c.watchersLock.Unlock()
} else if res.Xid == -2 {
// Ping response. Ignore.
} else if res.Xid < 0 {
log.Printf("Xid < 0 (%d) but not ping or watcher event", res.Xid)
} else {
if res.Zxid > 0 {
c.lastZxid = res.Zxid
}
c.requestsLock.Lock()
req, ok := c.requests[res.Xid]
if ok {
delete(c.requests, res.Xid)
}
c.requestsLock.Unlock()
if !ok {
log.Printf("Response for unknown request with xid %d", res.Xid)
} else {
if res.Err != 0 {
err = res.Err.toError()
} else {
_, err = decodePacket(buf[16:16+blen], req.recvStruct)
}
if req.recvFunc != nil {
req.recvFunc(req, &res, err)
}
req.recvChan <- response{res.Zxid, err}
if req.opcode == opClose {
return io.EOF
}
}
}
}
}
func (c *Conn) nextXid() int32 {
return atomic.AddInt32(&c.xid, 1)
}
func (c *Conn) addWatcher(path string, watchType watchType) <-chan Event {
c.watchersLock.Lock()
defer c.watchersLock.Unlock()
ch := make(chan Event, 1)
wpt := watchPathType{path, watchType}
c.watchers[wpt] = append(c.watchers[wpt], ch)
return ch
}
func (c *Conn) queueRequest(opcode int32, req interface{}, res interface{}, recvFunc func(*request, *responseHeader, error)) <-chan response {
rq := &request{
xid: c.nextXid(),
opcode: opcode,
pkt: req,
recvStruct: res,
recvChan: make(chan response, 1),
recvFunc: recvFunc,
}
c.sendChan <- rq
return rq.recvChan
}
func (c *Conn) request(opcode int32, req interface{}, res interface{}, recvFunc func(*request, *responseHeader, error)) (int64, error) {
r := <-c.queueRequest(opcode, req, res, recvFunc)
return r.zxid, r.err
}
func (c *Conn) AddAuth(scheme string, auth []byte) error {
_, err := c.request(opSetAuth, &setAuthRequest{Type: 0, Scheme: scheme, Auth: auth}, &setAuthResponse{}, nil)
return err
}
func (c *Conn) Children(path string) ([]string, Stat, error) {
res := &getChildren2Response{}
_, err := c.request(opGetChildren2, &getChildren2Request{Path: path, Watch: false}, res, nil)
return res.Children, &res.Stat, err
}
func (c *Conn) ChildrenW(path string) ([]string, Stat, <-chan Event, error) {
var ech <-chan Event
res := &getChildren2Response{}
_, err := c.request(opGetChildren2, &getChildren2Request{Path: path, Watch: true}, res, func(req *request, res *responseHeader, err error) {
if err == nil {
ech = c.addWatcher(path, watchTypeChild)
}
})
if err != nil {
return nil, nil, nil, err
}
return res.Children, &res.Stat, ech, err
}
func (c *Conn) Get(path string) ([]byte, Stat, error) {
res := &getDataResponse{}
_, err := c.request(opGetData, &getDataRequest{Path: path, Watch: false}, res, nil)
return res.Data, &res.Stat, err
}
// GetW returns the contents of a znode and sets a watch
func (c *Conn) GetW(path string) ([]byte, Stat, <-chan Event, error) {
var ech <-chan Event
res := &getDataResponse{}
_, err := c.request(opGetData, &getDataRequest{Path: path, Watch: true}, res, func(req *request, res *responseHeader, err error) {
if err == nil {
ech = c.addWatcher(path, watchTypeData)
}
})
if err != nil {
return nil, nil, nil, err
}
return res.Data, &res.Stat, ech, err
}
func (c *Conn) Set(path string, data []byte, version int32) (Stat, error) {
res := &setDataResponse{}
_, err := c.request(opSetData, &SetDataRequest{path, data, version}, res, nil)
return &res.Stat, err
}
func (c *Conn) Create(path string, data []byte, flags int32, acl []ACL) (string, error) {
res := &createResponse{}
_, err := c.request(opCreate, &CreateRequest{path, data, acl, flags}, res, nil)
return res.Path, err
}
// CreateProtectedEphemeralSequential fixes a race condition if the server crashes
// after it creates the node. On reconnect the session may still be valid so the
// ephemeral node still exists. Therefore, on reconnect we need to check if a node
// with a GUID generated on create exists.
func (c *Conn) CreateProtectedEphemeralSequential(path string, data []byte, acl []ACL) (string, error) {
var guid [16]byte
_, err := io.ReadFull(rand.Reader, guid[:16])
if err != nil {
return "", err
}
guidStr := fmt.Sprintf("%x", guid)
parts := strings.Split(path, "/")
parts[len(parts)-1] = fmt.Sprintf("%s%s-%s", protectedPrefix, guidStr, parts[len(parts)-1])
rootPath := strings.Join(parts[:len(parts)-1], "/")
protectedPath := strings.Join(parts, "/")
var newPath string
for i := 0; i < 3; i++ {
newPath, err = c.Create(protectedPath, data, FlagEphemeral|FlagSequence, acl)
switch err {
case ErrSessionExpired:
// No need to search for the node since it can't exist. Just try again.
case ErrConnectionClosed:
children, _, err := c.Children(rootPath)
if err != nil {
return "", err
}
for _, p := range children {
parts := strings.Split(p, "/")
if pth := parts[len(parts)-1]; strings.HasPrefix(pth, protectedPrefix) {
if g := pth[len(protectedPrefix) : len(protectedPrefix)+32]; g == guidStr {
return rootPath + "/" + p, nil
}
}
}
case nil:
return newPath, nil
default:
return "", err
}
}
return "", err
}
func (c *Conn) Delete(path string, version int32) error {
_, err := c.request(opDelete, &DeleteRequest{path, version}, &deleteResponse{}, nil)
return err
}
func (c *Conn) Exists(path string) (bool, Stat, error) {
res := &existsResponse{}
_, err := c.request(opExists, &existsRequest{Path: path, Watch: false}, res, nil)
exists := true
if err == ErrNoNode {
exists = false
err = nil
}
return exists, &res.Stat, err
}
func (c *Conn) ExistsW(path string) (bool, Stat, <-chan Event, error) {
var ech <-chan Event
res := &existsResponse{}
_, err := c.request(opExists, &existsRequest{Path: path, Watch: true}, res, func(req *request, res *responseHeader, err error) {
if err == nil {
ech = c.addWatcher(path, watchTypeData)
} else if err == ErrNoNode {
ech = c.addWatcher(path, watchTypeExist)
}
})
exists := true
if err == ErrNoNode {
exists = false
err = nil
}
if err != nil {
return false, nil, nil, err
}
return exists, &res.Stat, ech, err
}
func (c *Conn) GetACL(path string) ([]ACL, Stat, error) {
res := &getAclResponse{}
_, err := c.request(opGetAcl, &getAclRequest{Path: path}, res, nil)
return res.Acl, &res.Stat, err
}
func (c *Conn) SetACL(path string, acl []ACL, version int32) (Stat, error) {
res := &setAclResponse{}
_, err := c.request(opSetAcl, &setAclRequest{Path: path, Acl: acl, Version: version}, res, nil)
return &res.Stat, err
}
func (c *Conn) Sync(path string) (string, error) {
res := &syncResponse{}
_, err := c.request(opSync, &syncRequest{Path: path}, res, nil)
return res.Path, err
}
type MultiOps struct {
Create []CreateRequest
Delete []DeleteRequest
SetData []SetDataRequest
Check []CheckVersionRequest
}
func (c *Conn) Multi(ops MultiOps) error {
req := &multiRequest{
Ops: make([]multiRequestOp, 0, len(ops.Create)+len(ops.Delete)+len(ops.SetData)+len(ops.Check)),
DoneHeader: multiHeader{Type: -1, Done: true, Err: -1},
}
for _, r := range ops.Create {
req.Ops = append(req.Ops, multiRequestOp{multiHeader{opCreate, false, -1}, r})
}
for _, r := range ops.SetData {
req.Ops = append(req.Ops, multiRequestOp{multiHeader{opSetData, false, -1}, r})
}
for _, r := range ops.Delete {
req.Ops = append(req.Ops, multiRequestOp{multiHeader{opDelete, false, -1}, r})
}
for _, r := range ops.Check {
req.Ops = append(req.Ops, multiRequestOp{multiHeader{opCheck, false, -1}, r})
}
res := &multiResponse{}
_, err := c.request(opMulti, req, res, nil)
return err
}

217
vendor/github.com/ngaut/go-zookeeper/zk/constants.go generated vendored
View file

@ -1,217 +0,0 @@
package zk
import (
"errors"
)
const (
protocolVersion = 0
DefaultPort = 2181
)
const (
opNotify = 0
opCreate = 1
opDelete = 2
opExists = 3
opGetData = 4
opSetData = 5
opGetAcl = 6
opSetAcl = 7
opGetChildren = 8
opSync = 9
opPing = 11
opGetChildren2 = 12
opCheck = 13
opMulti = 14
opClose = -11
opSetAuth = 100
opSetWatches = 101
// Not in protocol, used internally
opWatcherEvent = -2
)
const (
EventNodeCreated = EventType(1)
EventNodeDeleted = EventType(2)
EventNodeDataChanged = EventType(3)
EventNodeChildrenChanged = EventType(4)
EventSession = EventType(-1)
EventNotWatching = EventType(-2)
)
var (
eventNames = map[EventType]string{
EventNodeCreated: "EventNodeCreated",
EventNodeDeleted: "EventNodeDeleted",
EventNodeDataChanged: "EventNodeDataChanged",
EventNodeChildrenChanged: "EventNodeChildrenChanged",
EventSession: "EventSession",
EventNotWatching: "EventNotWatching",
}
)
const (
StateUnknown = State(-1)
StateDisconnected = State(0)
StateConnecting = State(1)
StateSyncConnected = State(3)
StateAuthFailed = State(4)
StateConnectedReadOnly = State(5)
StateSaslAuthenticated = State(6)
StateExpired = State(-112)
// StateAuthFailed = State(-113)
StateConnected = State(100)
StateHasSession = State(101)
)
const (
FlagEphemeral = 1
FlagSequence = 2
)
var (
stateNames = map[State]string{
StateUnknown: "StateUnknown",
StateDisconnected: "StateDisconnected",
StateSyncConnected: "StateSyncConnected",
StateConnectedReadOnly: "StateConnectedReadOnly",
StateSaslAuthenticated: "StateSaslAuthenticated",
StateExpired: "StateExpired",
StateAuthFailed: "StateAuthFailed",
StateConnecting: "StateConnecting",
StateConnected: "StateConnected",
StateHasSession: "StateHasSession",
}
)
type State int32
func (s State) String() string {
if name := stateNames[s]; name != "" {
return name
}
return "Unknown"
}
type ErrCode int32
var (
ErrConnectionClosed = errors.New("zk: connection closed")
ErrUnknown = errors.New("zk: unknown error")
ErrAPIError = errors.New("zk: api error")
ErrNoNode = errors.New("zk: node does not exist")
ErrNoAuth = errors.New("zk: not authenticated")
ErrBadVersion = errors.New("zk: version conflict")
ErrNoChildrenForEphemerals = errors.New("zk: ephemeral nodes may not have children")
ErrNodeExists = errors.New("zk: node already exists")
ErrNotEmpty = errors.New("zk: node has children")
ErrSessionExpired = errors.New("zk: session has been expired by the server")
ErrInvalidACL = errors.New("zk: invalid ACL specified")
ErrAuthFailed = errors.New("zk: client authentication failed")
ErrClosing = errors.New("zk: zookeeper is closing")
ErrNothing = errors.New("zk: no server responsees to process")
ErrSessionMoved = errors.New("zk: session moved to another server, so operation is ignored")
// ErrInvalidCallback = errors.New("zk: invalid callback specified")
errCodeToError = map[ErrCode]error{
0: nil,
errAPIError: ErrAPIError,
errNoNode: ErrNoNode,
errNoAuth: ErrNoAuth,
errBadVersion: ErrBadVersion,
errNoChildrenForEphemerals: ErrNoChildrenForEphemerals,
errNodeExists: ErrNodeExists,
errNotEmpty: ErrNotEmpty,
errSessionExpired: ErrSessionExpired,
// errInvalidCallback: ErrInvalidCallback,
errInvalidAcl: ErrInvalidACL,
errAuthFailed: ErrAuthFailed,
errClosing: ErrClosing,
errNothing: ErrNothing,
errSessionMoved: ErrSessionMoved,
}
)
func (e ErrCode) toError() error {
if err, ok := errCodeToError[e]; ok {
return err
}
return ErrUnknown
}
const (
errOk = 0
// System and server-side errors
errSystemError = -1
errRuntimeInconsistency = -2
errDataInconsistency = -3
errConnectionLoss = -4
errMarshallingError = -5
errUnimplemented = -6
errOperationTimeout = -7
errBadArguments = -8
errInvalidState = -9
// API errors
errAPIError = ErrCode(-100)
errNoNode = ErrCode(-101) // *
errNoAuth = ErrCode(-102)
errBadVersion = ErrCode(-103) // *
errNoChildrenForEphemerals = ErrCode(-108)
errNodeExists = ErrCode(-110) // *
errNotEmpty = ErrCode(-111)
errSessionExpired = ErrCode(-112)
errInvalidCallback = ErrCode(-113)
errInvalidAcl = ErrCode(-114)
errAuthFailed = ErrCode(-115)
errClosing = ErrCode(-116)
errNothing = ErrCode(-117)
errSessionMoved = ErrCode(-118)
)
// Constants for ACL permissions
const (
PermRead = 1 << iota
PermWrite
PermCreate
PermDelete
PermAdmin
PermAll = 0x1f
)
var (
emptyPassword = []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
opNames = map[int32]string{
opNotify: "notify",
opCreate: "create",
opDelete: "delete",
opExists: "exists",
opGetData: "getData",
opSetData: "setData",
opGetAcl: "getACL",
opSetAcl: "setACL",
opGetChildren: "getChildren",
opSync: "sync",
opPing: "ping",
opGetChildren2: "getChildren2",
opCheck: "check",
opMulti: "multi",
opClose: "close",
opSetAuth: "setAuth",
opSetWatches: "setWatches",
opWatcherEvent: "watcherEvent",
}
)
type EventType int32
func (t EventType) String() string {
if name := eventNames[t]; name != "" {
return name
}
return "Unknown"
}

131
vendor/github.com/ngaut/go-zookeeper/zk/lock.go generated vendored
View file

@ -1,131 +0,0 @@
package zk
import (
"errors"
"fmt"
"strconv"
"strings"
)
var (
ErrDeadlock = errors.New("zk: trying to acquire a lock twice")
ErrNotLocked = errors.New("zk: not locked")
)
type Lock struct {
c *Conn
path string
acl []ACL
lockPath string
seq int
}
func NewLock(c *Conn, path string, acl []ACL) *Lock {
return &Lock{
c: c,
path: path,
acl: acl,
}
}
func parseSeq(path string) (int, error) {
parts := strings.Split(path, "-")
return strconv.Atoi(parts[len(parts)-1])
}
func (l *Lock) Lock() error {
if l.lockPath != "" {
return ErrDeadlock
}
prefix := fmt.Sprintf("%s/lock-", l.path)
path := ""
var err error
for i := 0; i < 3; i++ {
path, err = l.c.CreateProtectedEphemeralSequential(prefix, []byte{}, l.acl)
if err == ErrNoNode {
// Create parent node.
parts := strings.Split(l.path, "/")
pth := ""
for _, p := range parts[1:] {
pth += "/" + p
_, err := l.c.Create(pth, []byte{}, 0, l.acl)
if err != nil && err != ErrNodeExists {
return err
}
}
} else if err == nil {
break
} else {
return err
}
}
if err != nil {
return err
}
seq, err := parseSeq(path)
if err != nil {
return err
}
for {
children, _, err := l.c.Children(l.path)
if err != nil {
return err
}
lowestSeq := seq
prevSeq := 0
prevSeqPath := ""
for _, p := range children {
s, err := parseSeq(p)
if err != nil {
return err
}
if s < lowestSeq {
lowestSeq = s
}
if s < seq && s > prevSeq {
prevSeq = s
prevSeqPath = p
}
}
if seq == lowestSeq {
// Acquired the lock
break
}
// Wait on the node next in line for the lock
_, _, ch, err := l.c.GetW(l.path + "/" + prevSeqPath)
if err != nil && err != ErrNoNode {
return err
} else if err != nil && err == ErrNoNode {
// try again
continue
}
ev := <-ch
if ev.Err != nil {
return ev.Err
}
}
l.seq = seq
l.lockPath = path
return nil
}
func (l *Lock) Unlock() error {
if l.lockPath == "" {
return ErrNotLocked
}
if err := l.c.Delete(l.lockPath, -1); err != nil {
return err
}
l.lockPath = ""
l.seq = 0
return nil
}

113
vendor/github.com/ngaut/go-zookeeper/zk/server_help.go generated vendored
View file

@ -1,113 +0,0 @@
package zk
import (
"fmt"
"io/ioutil"
"math/rand"
"os"
"path/filepath"
"time"
)
type TestServer struct {
Port int
Path string
Srv *Server
}
type TestCluster struct {
Path string
Servers []TestServer
}
func StartTestCluster(size int) (*TestCluster, error) {
tmpPath, err := ioutil.TempDir("", "gozk")
if err != nil {
return nil, err
}
success := false
startPort := int(rand.Int31n(6000) + 10000)
cluster := &TestCluster{Path: tmpPath}
defer func() {
if !success {
cluster.Stop()
}
}()
for serverN := 0; serverN < size; serverN++ {
srvPath := filepath.Join(tmpPath, fmt.Sprintf("srv%d", serverN))
if err := os.Mkdir(srvPath, 0700); err != nil {
return nil, err
}
port := startPort + serverN*3
cfg := ServerConfig{
ClientPort: port,
DataDir: srvPath,
}
for i := 0; i < size; i++ {
cfg.Servers = append(cfg.Servers, ServerConfigServer{
ID: i + 1,
Host: "127.0.0.1",
PeerPort: startPort + i*3 + 1,
LeaderElectionPort: startPort + i*3 + 2,
})
}
cfgPath := filepath.Join(srvPath, "zoo.cfg")
fi, err := os.Create(cfgPath)
if err != nil {
return nil, err
}
err = cfg.Marshall(fi)
fi.Close()
if err != nil {
return nil, err
}
fi, err = os.Create(filepath.Join(srvPath, "myid"))
if err != nil {
return nil, err
}
_, err = fmt.Fprintf(fi, "%d\n", serverN+1)
fi.Close()
if err != nil {
return nil, err
}
srv := &Server{
ConfigPath: cfgPath,
}
if err := srv.Start(); err != nil {
fmt.Println(err)
return nil, err
}
cluster.Servers = append(cluster.Servers, TestServer{
Path: srvPath,
Port: cfg.ClientPort,
Srv: srv,
})
}
success = true
time.Sleep(time.Second) // Give the server time to become active. Should probably actually attempt to connect to verify.
return cluster, nil
}
func (ts *TestCluster) Connect(idx int) (*Conn, error) {
zk, _, err := Connect([]string{fmt.Sprintf("127.0.0.1:%d", ts.Servers[idx].Port)}, time.Second*15)
return zk, err
}
func (ts *TestCluster) ConnectAll() (*Conn, error) {
hosts := make([]string, len(ts.Servers))
for i, srv := range ts.Servers {
hosts[i] = fmt.Sprintf("127.0.0.1:%d", srv.Port)
}
zk, _, err := Connect(hosts, time.Second*15)
return zk, err
}
func (ts *TestCluster) Stop() error {
for _, srv := range ts.Servers {
srv.Srv.Stop()
}
defer os.RemoveAll(ts.Path)
return nil
}

142
vendor/github.com/ngaut/go-zookeeper/zk/server_java.go generated vendored
View file

@ -1,142 +0,0 @@
package zk
import (
"fmt"
"io"
"os"
"os/exec"
"path/filepath"
)
type ErrMissingServerConfigField string
func (e ErrMissingServerConfigField) Error() string {
return fmt.Sprintf("zk: missing server config field '%s'", string(e))
}
const (
DefaultServerTickTime = 2000
DefaultServerInitLimit = 10
DefaultServerSyncLimit = 5
DefaultServerAutoPurgeSnapRetainCount = 3
DefaultPeerPort = 2888
DefaultLeaderElectionPort = 3888
)
type ServerConfigServer struct {
ID int
Host string
PeerPort int
LeaderElectionPort int
}
type ServerConfig struct {
TickTime int // Number of milliseconds of each tick
InitLimit int // Number of ticks that the initial synchronization phase can take
SyncLimit int // Number of ticks that can pass between sending a request and getting an acknowledgement
DataDir string // Direcrory where the snapshot is stored
ClientPort int // Port at which clients will connect
AutoPurgeSnapRetainCount int // Number of snapshots to retain in dataDir
AutoPurgePurgeInterval int // Purge task internal in hours (0 to disable auto purge)
Servers []ServerConfigServer
}
func (sc ServerConfig) Marshall(w io.Writer) error {
if sc.DataDir == "" {
return ErrMissingServerConfigField("dataDir")
}
fmt.Fprintf(w, "dataDir=%s\n", sc.DataDir)
if sc.TickTime <= 0 {
sc.TickTime = DefaultServerTickTime
}
fmt.Fprintf(w, "tickTime=%d\n", sc.TickTime)
if sc.InitLimit <= 0 {
sc.InitLimit = DefaultServerInitLimit
}
fmt.Fprintf(w, "initLimit=%d\n", sc.InitLimit)
if sc.SyncLimit <= 0 {
sc.SyncLimit = DefaultServerSyncLimit
}
fmt.Fprintf(w, "syncLimit=%d\n", sc.SyncLimit)
if sc.ClientPort <= 0 {
sc.ClientPort = DefaultPort
}
fmt.Fprintf(w, "clientPort=%d\n", sc.ClientPort)
if sc.AutoPurgePurgeInterval > 0 {
if sc.AutoPurgeSnapRetainCount <= 0 {
sc.AutoPurgeSnapRetainCount = DefaultServerAutoPurgeSnapRetainCount
}
fmt.Fprintf(w, "autopurge.snapRetainCount=%d\n", sc.AutoPurgeSnapRetainCount)
fmt.Fprintf(w, "autopurge.purgeInterval=%d\n", sc.AutoPurgePurgeInterval)
}
if len(sc.Servers) > 0 {
for _, srv := range sc.Servers {
if srv.PeerPort <= 0 {
srv.PeerPort = DefaultPeerPort
}
if srv.LeaderElectionPort <= 0 {
srv.LeaderElectionPort = DefaultLeaderElectionPort
}
fmt.Fprintf(w, "server.%d=%s:%d:%d\n", srv.ID, srv.Host, srv.PeerPort, srv.LeaderElectionPort)
}
}
return nil
}
var jarSearchPaths = []string{
"zookeeper-*/contrib/fatjar/zookeeper-*-fatjar.jar",
"../zookeeper-*/contrib/fatjar/zookeeper-*-fatjar.jar",
"/usr/share/java/zookeeper-*.jar",
"/usr/local/zookeeper-*/contrib/fatjar/zookeeper-*-fatjar.jar",
"/usr/local/Cellar/zookeeper/*/libexec/contrib/fatjar/zookeeper-*-fatjar.jar",
}
func findZookeeperFatJar() string {
var paths []string
zkPath := os.Getenv("ZOOKEEPER_PATH")
if zkPath == "" {
paths = jarSearchPaths
} else {
paths = []string{filepath.Join(zkPath, "contrib/fatjar/zookeeper-*-fatjar.jar")}
}
for _, path := range paths {
matches, _ := filepath.Glob(path)
// TODO: could sort by version and pick latest
if len(matches) > 0 {
return matches[0]
}
}
return ""
}
type Server struct {
JarPath string
ConfigPath string
cmd *exec.Cmd
}
func (srv *Server) Start() error {
if srv.JarPath == "" {
srv.JarPath = findZookeeperFatJar()
if srv.JarPath == "" {
return fmt.Errorf("zk: unable to find server jar")
}
}
srv.cmd = exec.Command("java", "-jar", srv.JarPath, "server", srv.ConfigPath)
// srv.cmd.Stdout = os.Stdout
// srv.cmd.Stderr = os.Stderr
err := srv.cmd.Start()
if err != nil {
fmt.Println("start failed", err)
}
fmt.Println("start zookeeper ok")
return err
}
func (srv *Server) Stop() error {
srv.cmd.Process.Signal(os.Kill)
return srv.cmd.Wait()
}

662
vendor/github.com/ngaut/go-zookeeper/zk/structs.go generated vendored
View file

@ -1,662 +0,0 @@
package zk
import (
"encoding/binary"
"errors"
"reflect"
"runtime"
"time"
)
var (
ErrUnhandledFieldType = errors.New("zk: unhandled field type")
ErrPtrExpected = errors.New("zk: encode/decode expect a non-nil pointer to struct")
ErrShortBuffer = errors.New("zk: buffer too small")
)
type ACL struct {
Perms int32
Scheme string
ID string
}
type zkstat struct {
ZCzxid int64 // The zxid of the change that caused this znode to be created.
ZMzxid int64 // The zxid of the change that last modified this znode.
ZCtime int64 // The time in milliseconds from epoch when this znode was created.
ZMtime int64 // The time in milliseconds from epoch when this znode was last modified.
ZVersion int32 // The number of changes to the data of this znode.
ZCversion int32 // The number of changes to the children of this znode.
ZAversion int32 // The number of changes to the ACL of this znode.
ZEphemeralOwner int64 // The session id of the owner of this znode if the znode is an ephemeral node. If it is not an ephemeral node, it will be zero.
ZDataLength int32 // The length of the data field of this znode.
ZNumChildren int32 // The number of children of this znode.
ZPzxid int64 // last modified children
}
type Stat interface {
Czxid() int64
Mzxid() int64
CTime() time.Time
MTime() time.Time
Version() int
CVersion() int
AVersion() int
EphemeralOwner() int64
DataLength() int
NumChildren() int
Pzxid() int64
}
// Czxid returns the zxid of the change that caused the node to be created.
func (s *zkstat) Czxid() int64 {
return s.ZCzxid
}
// Mzxid returns the zxid of the change that last modified the node.
func (s *zkstat) Mzxid() int64 {
return s.ZMzxid
}
func millisec2time(ms int64) time.Time {
return time.Unix(ms/1e3, ms%1e3*1e6)
}
// CTime returns the time (at millisecond resolution) when the node was
// created.
func (s *zkstat) CTime() time.Time {
return millisec2time(s.ZCtime)
}
// MTime returns the time (at millisecond resolution) when the node was
// last modified.
func (s *zkstat) MTime() time.Time {
return millisec2time(int64(s.ZMtime))
}
// Version returns the number of changes to the data of the node.
func (s *zkstat) Version() int {
return int(s.ZVersion)
}
// CVersion returns the number of changes to the children of the node.
// This only changes when children are created or removed.
func (s *zkstat) CVersion() int {
return int(s.ZCversion)
}
// AVersion returns the number of changes to the ACL of the node.
func (s *zkstat) AVersion() int {
return int(s.ZAversion)
}
// If the node is an ephemeral node, EphemeralOwner returns the session id
// of the owner of the node; otherwise it will return zero.
func (s *zkstat) EphemeralOwner() int64 {
return int64(s.ZEphemeralOwner)
}
// DataLength returns the length of the data in the node in bytes.
func (s *zkstat) DataLength() int {
return int(s.ZDataLength)
}
// NumChildren returns the number of children of the node.
func (s *zkstat) NumChildren() int {
return int(s.ZNumChildren)
}
// Pzxid returns the Pzxid of the node, whatever that is.
func (s *zkstat) Pzxid() int64 {
return int64(s.ZPzxid)
}
type requestHeader struct {
Xid int32
Opcode int32
}
type responseHeader struct {
Xid int32
Zxid int64
Err ErrCode
}
type multiHeader struct {
Type int32
Done bool
Err ErrCode
}
type auth struct {
Type int32
Scheme string
Auth []byte
}
// Generic request structs
type pathRequest struct {
Path string
}
type PathVersionRequest struct {
Path string
Version int32
}
type pathWatchRequest struct {
Path string
Watch bool
}
type pathResponse struct {
Path string
}
type statResponse struct {
Stat zkstat
}
//
type CheckVersionRequest PathVersionRequest
type closeRequest struct{}
type closeResponse struct{}
type connectRequest struct {
ProtocolVersion int32
LastZxidSeen int64
TimeOut int32
SessionID int64
Passwd []byte
}
type connectResponse struct {
ProtocolVersion int32
TimeOut int32
SessionID int64
Passwd []byte
}
type CreateRequest struct {
Path string
Data []byte
Acl []ACL
Flags int32
}
type createResponse pathResponse
type DeleteRequest PathVersionRequest
type deleteResponse struct{}
type errorResponse struct {
Err int32
}
type existsRequest pathWatchRequest
type existsResponse statResponse
type getAclRequest pathRequest
type getAclResponse struct {
Acl []ACL
Stat zkstat
}
type getChildrenRequest pathRequest
type getChildrenResponse struct {
Children []string
}
type getChildren2Request pathWatchRequest
type getChildren2Response struct {
Children []string
Stat zkstat
}
type getDataRequest pathWatchRequest
type getDataResponse struct {
Data []byte
Stat zkstat
}
type getMaxChildrenRequest pathRequest
type getMaxChildrenResponse struct {
Max int32
}
type getSaslRequest struct {
Token []byte
}
type pingRequest struct{}
type pingResponse struct{}
type setAclRequest struct {
Path string
Acl []ACL
Version int32
}
type setAclResponse statResponse
type SetDataRequest struct {
Path string
Data []byte
Version int32
}
type setDataResponse statResponse
type setMaxChildren struct {
Path string
Max int32
}
type setSaslRequest struct {
Token string
}
type setSaslResponse struct {
Token string
}
type setWatchesRequest struct {
RelativeZxid int64
DataWatches []string
ExistWatches []string
ChildWatches []string
}
type setWatchesResponse struct{}
type syncRequest pathRequest
type syncResponse pathResponse
type setAuthRequest auth
type setAuthResponse struct{}
type multiRequestOp struct {
Header multiHeader
Op interface{}
}
type multiRequest struct {
Ops []multiRequestOp
DoneHeader multiHeader
}
type multiResponseOp struct {
Header multiHeader
String string
Stat *zkstat
}
type multiResponse struct {
Ops []multiResponseOp
DoneHeader multiHeader
}
func (r *multiRequest) Encode(buf []byte) (int, error) {
total := 0
for _, op := range r.Ops {
op.Header.Done = false
n, err := encodePacketValue(buf[total:], reflect.ValueOf(op))
if err != nil {
return total, err
}
total += n
}
r.DoneHeader.Done = true
n, err := encodePacketValue(buf[total:], reflect.ValueOf(r.DoneHeader))
if err != nil {
return total, err
}
total += n
return total, nil
}
func (r *multiRequest) Decode(buf []byte) (int, error) {
r.Ops = make([]multiRequestOp, 0)
r.DoneHeader = multiHeader{-1, true, -1}
total := 0
for {
header := &multiHeader{}
n, err := decodePacketValue(buf[total:], reflect.ValueOf(header))
if err != nil {
return total, err
}
total += n
if header.Done {
r.DoneHeader = *header
break
}
req := requestStructForOp(header.Type)
if req == nil {
return total, ErrAPIError
}
n, err = decodePacketValue(buf[total:], reflect.ValueOf(req))
if err != nil {
return total, err
}
total += n
r.Ops = append(r.Ops, multiRequestOp{*header, req})
}
return total, nil
}
func (r *multiResponse) Decode(buf []byte) (int, error) {
r.Ops = make([]multiResponseOp, 0)
r.DoneHeader = multiHeader{-1, true, -1}
total := 0
for {
header := &multiHeader{}
n, err := decodePacketValue(buf[total:], reflect.ValueOf(header))
if err != nil {
return total, err
}
total += n
if header.Done {
r.DoneHeader = *header
break
}
res := multiResponseOp{Header: *header}
var w reflect.Value
switch header.Type {
default:
return total, ErrAPIError
case opCreate:
w = reflect.ValueOf(&res.String)
case opSetData:
res.Stat = new(zkstat)
w = reflect.ValueOf(res.Stat)
case opCheck, opDelete:
}
if w.IsValid() {
n, err := decodePacketValue(buf[total:], w)
if err != nil {
return total, err
}
total += n
}
r.Ops = append(r.Ops, res)
}
return total, nil
}
type watcherEvent struct {
Type EventType
State State
Path string
}
type decoder interface {
Decode(buf []byte) (int, error)
}
type encoder interface {
Encode(buf []byte) (int, error)
}
func decodePacket(buf []byte, st interface{}) (n int, err error) {
defer func() {
if r := recover(); r != nil {
if e, ok := r.(runtime.Error); ok && e.Error() == "runtime error: slice bounds out of range" {
err = ErrShortBuffer
} else {
panic(r)
}
}
}()
v := reflect.ValueOf(st)
if v.Kind() != reflect.Ptr || v.IsNil() {
return 0, ErrPtrExpected
}
return decodePacketValue(buf, v)
}
func decodePacketValue(buf []byte, v reflect.Value) (int, error) {
rv := v
kind := v.Kind()
if kind == reflect.Ptr {
if v.IsNil() {
v.Set(reflect.New(v.Type().Elem()))
}
v = v.Elem()
kind = v.Kind()
}
n := 0
switch kind {
default:
return n, ErrUnhandledFieldType
case reflect.Struct:
if de, ok := rv.Interface().(decoder); ok {
return de.Decode(buf)
} else if de, ok := v.Interface().(decoder); ok {
return de.Decode(buf)
} else {
for i := 0; i < v.NumField(); i++ {
field := v.Field(i)
n2, err := decodePacketValue(buf[n:], field)
n += n2
if err != nil {
return n, err
}
}
}
case reflect.Bool:
v.SetBool(buf[n] != 0)
n++
case reflect.Int32:
v.SetInt(int64(binary.BigEndian.Uint32(buf[n : n+4])))
n += 4
case reflect.Int64:
v.SetInt(int64(binary.BigEndian.Uint64(buf[n : n+8])))
n += 8
case reflect.String:
ln := int(binary.BigEndian.Uint32(buf[n : n+4]))
v.SetString(string(buf[n+4 : n+4+ln]))
n += 4 + ln
case reflect.Slice:
switch v.Type().Elem().Kind() {
default:
count := int(binary.BigEndian.Uint32(buf[n : n+4]))
n += 4
values := reflect.MakeSlice(v.Type(), count, count)
v.Set(values)
for i := 0; i < count; i++ {
n2, err := decodePacketValue(buf[n:], values.Index(i))
n += n2
if err != nil {
return n, err
}
}
case reflect.Uint8:
ln := int(int32(binary.BigEndian.Uint32(buf[n : n+4])))
if ln < 0 {
n += 4
v.SetBytes(nil)
} else {
bytes := make([]byte, ln)
copy(bytes, buf[n+4:n+4+ln])
v.SetBytes(bytes)
n += 4 + ln
}
}
}
return n, nil
}
func encodePacket(buf []byte, st interface{}) (n int, err error) {
defer func() {
if r := recover(); r != nil {
if e, ok := r.(runtime.Error); ok && e.Error() == "runtime error: slice bounds out of range" {
err = ErrShortBuffer
} else {
panic(r)
}
}
}()
v := reflect.ValueOf(st)
if v.Kind() != reflect.Ptr || v.IsNil() {
return 0, ErrPtrExpected
}
return encodePacketValue(buf, v)
}
func encodePacketValue(buf []byte, v reflect.Value) (int, error) {
rv := v
for v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface {
v = v.Elem()
}
n := 0
switch v.Kind() {
default:
return n, ErrUnhandledFieldType
case reflect.Struct:
if en, ok := rv.Interface().(encoder); ok {
return en.Encode(buf)
} else if en, ok := v.Interface().(encoder); ok {
return en.Encode(buf)
} else {
for i := 0; i < v.NumField(); i++ {
field := v.Field(i)
n2, err := encodePacketValue(buf[n:], field)
n += n2
if err != nil {
return n, err
}
}
}
case reflect.Bool:
if v.Bool() {
buf[n] = 1
} else {
buf[n] = 0
}
n++
case reflect.Int32:
binary.BigEndian.PutUint32(buf[n:n+4], uint32(v.Int()))
n += 4
case reflect.Int64:
binary.BigEndian.PutUint64(buf[n:n+8], uint64(v.Int()))
n += 8
case reflect.String:
str := v.String()
binary.BigEndian.PutUint32(buf[n:n+4], uint32(len(str)))
copy(buf[n+4:n+4+len(str)], []byte(str))
n += 4 + len(str)
case reflect.Slice:
switch v.Type().Elem().Kind() {
default:
count := v.Len()
startN := n
n += 4
for i := 0; i < count; i++ {
n2, err := encodePacketValue(buf[n:], v.Index(i))
n += n2
if err != nil {
return n, err
}
}
binary.BigEndian.PutUint32(buf[startN:startN+4], uint32(count))
case reflect.Uint8:
if v.IsNil() {
binary.BigEndian.PutUint32(buf[n:n+4], uint32(0xffffffff))
n += 4
} else {
bytes := v.Bytes()
binary.BigEndian.PutUint32(buf[n:n+4], uint32(len(bytes)))
copy(buf[n+4:n+4+len(bytes)], bytes)
n += 4 + len(bytes)
}
}
}
return n, nil
}
func requestStructForOp(op int32) interface{} {
switch op {
case opClose:
return &closeRequest{}
case opCreate:
return &CreateRequest{}
case opDelete:
return &DeleteRequest{}
case opExists:
return &existsRequest{}
case opGetAcl:
return &getAclRequest{}
case opGetChildren:
return &getChildrenRequest{}
case opGetChildren2:
return &getChildren2Request{}
case opGetData:
return &getDataRequest{}
case opPing:
return &pingRequest{}
case opSetAcl:
return &setAclRequest{}
case opSetData:
return &SetDataRequest{}
case opSetWatches:
return &setWatchesRequest{}
case opSync:
return &syncRequest{}
case opSetAuth:
return &setAuthRequest{}
case opCheck:
return &CheckVersionRequest{}
case opMulti:
return &multiRequest{}
}
return nil
}
func responseStructForOp(op int32) interface{} {
switch op {
case opClose:
return &closeResponse{}
case opCreate:
return &createResponse{}
case opDelete:
return &deleteResponse{}
case opExists:
return &existsResponse{}
case opGetAcl:
return &getAclResponse{}
case opGetChildren:
return &getChildrenResponse{}
case opGetChildren2:
return &getChildren2Response{}
case opGetData:
return &getDataResponse{}
case opPing:
return &pingResponse{}
case opSetAcl:
return &setAclResponse{}
case opSetData:
return &setDataResponse{}
case opSetWatches:
return &setWatchesResponse{}
case opSync:
return &syncResponse{}
case opWatcherEvent:
return &watcherEvent{}
case opSetAuth:
return &setAuthResponse{}
// case opCheck:
// return &checkVersionResponse{}
case opMulti:
return &multiResponse{}
}
return nil
}

149
vendor/github.com/ngaut/go-zookeeper/zk/tracer.go generated vendored
View file

@ -1,149 +0,0 @@
package zk
import (
"encoding/binary"
"fmt"
"io"
"net"
"sync"
)
var (
requests = make(map[int32]int32) // Map of Xid -> Opcode
requestsLock = &sync.Mutex{}
)
func trace(conn1, conn2 net.Conn, client bool) {
defer conn1.Close()
defer conn2.Close()
buf := make([]byte, 10*1024)
init := true
for {
_, err := io.ReadFull(conn1, buf[:4])
if err != nil {
fmt.Println("1>", client, err)
return
}
blen := int(binary.BigEndian.Uint32(buf[:4]))
_, err = io.ReadFull(conn1, buf[4:4+blen])
if err != nil {
fmt.Println("2>", client, err)
return
}
var cr interface{}
opcode := int32(-1)
readHeader := true
if client {
if init {
cr = &connectRequest{}
readHeader = false
} else {
xid := int32(binary.BigEndian.Uint32(buf[4:8]))
opcode = int32(binary.BigEndian.Uint32(buf[8:12]))
requestsLock.Lock()
requests[xid] = opcode
requestsLock.Unlock()
cr = requestStructForOp(opcode)
if cr == nil {
fmt.Printf("Unknown opcode %d\n", opcode)
}
}
} else {
if init {
cr = &connectResponse{}
readHeader = false
} else {
xid := int32(binary.BigEndian.Uint32(buf[4:8]))
zxid := int64(binary.BigEndian.Uint64(buf[8:16]))
errnum := int32(binary.BigEndian.Uint32(buf[16:20]))
if xid != -1 || zxid != -1 {
requestsLock.Lock()
found := false
opcode, found = requests[xid]
if !found {
println("WEFWEFEW")
opcode = 0
}
delete(requests, xid)
requestsLock.Unlock()
} else {
opcode = opWatcherEvent
}
cr = responseStructForOp(opcode)
if cr == nil {
fmt.Printf("Unknown opcode %d\n", opcode)
}
if errnum != 0 {
cr = &struct{}{}
}
}
}
opname := "."
if opcode != -1 {
opname = opNames[opcode]
}
if cr == nil {
fmt.Printf("%+v %s %+v\n", client, opname, buf[4:4+blen])
} else {
n := 4
hdrStr := ""
if readHeader {
var hdr interface{}
if client {
hdr = &requestHeader{}
} else {
hdr = &responseHeader{}
}
if n2, err := decodePacket(buf[n:n+blen], hdr); err != nil {
fmt.Println(err)
} else {
n += n2
}
hdrStr = fmt.Sprintf(" %+v", hdr)
}
if _, err := decodePacket(buf[n:n+blen], cr); err != nil {
fmt.Println(err)
}
fmt.Printf("%+v %s%s %+v\n", client, opname, hdrStr, cr)
}
init = false
written, err := conn2.Write(buf[:4+blen])
if err != nil {
fmt.Println("3>", client, err)
return
} else if written != 4+blen {
fmt.Printf("Written != read: %d != %d\n", written, blen)
return
}
}
}
func handleConnection(addr string, conn net.Conn) {
zkConn, err := net.Dial("tcp", addr)
if err != nil {
fmt.Println(err)
return
}
go trace(conn, zkConn, true)
trace(zkConn, conn, false)
}
func StartTracer(listenAddr, serverAddr string) {
ln, err := net.Listen("tcp", listenAddr)
if err != nil {
panic(err)
}
for {
conn, err := ln.Accept()
if err != nil {
fmt.Println(err)
continue
}
go handleConnection(serverAddr, conn)
}
}

40
vendor/github.com/ngaut/go-zookeeper/zk/util.go generated vendored
View file

@ -1,40 +0,0 @@
package zk
import (
"crypto/sha1"
"encoding/base64"
"fmt"
"math/rand"
)
// AuthACL produces an ACL list containing a single ACL which uses the
// provided permissions, with the scheme "auth", and ID "", which is used
// by ZooKeeper to represent any authenticated user.
func AuthACL(perms int32) []ACL {
return []ACL{{perms, "auth", ""}}
}
// WorldACL produces an ACL list containing a single ACL which uses the
// provided permissions, with the scheme "world", and ID "anyone", which
// is used by ZooKeeper to represent any user at all.
func WorldACL(perms int32) []ACL {
return []ACL{{perms, "world", "anyone"}}
}
func DigestACL(perms int32, user, password string) []ACL {
userPass := []byte(fmt.Sprintf("%s:%s", user, password))
h := sha1.New()
if n, err := h.Write(userPass); err != nil || n != len(userPass) {
panic("SHA1 failed")
}
digest := base64.StdEncoding.EncodeToString(h.Sum(nil))
return []ACL{{perms, "digest", fmt.Sprintf("%s:%s", user, digest)}}
}
// stringShuffle performs a Fisher-Yates shuffle on a slice of strings
func stringShuffle(s []string) {
for i := len(s) - 1; i > 0; i-- {
j := rand.Intn(i + 1)
s[i], s[j] = s[j], s[i]
}
}

165
vendor/github.com/ngaut/log/LICENSE generated vendored
View file

@ -1,165 +0,0 @@
GNU LESSER GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
This version of the GNU Lesser General Public License incorporates
the terms and conditions of version 3 of the GNU General Public
License, supplemented by the additional permissions listed below.
0. Additional Definitions.
As used herein, "this License" refers to version 3 of the GNU Lesser
General Public License, and the "GNU GPL" refers to version 3 of the GNU
General Public License.
"The Library" refers to a covered work governed by this License,
other than an Application or a Combined Work as defined below.
An "Application" is any work that makes use of an interface provided
by the Library, but which is not otherwise based on the Library.
Defining a subclass of a class defined by the Library is deemed a mode
of using an interface provided by the Library.
A "Combined Work" is a work produced by combining or linking an
Application with the Library. The particular version of the Library
with which the Combined Work was made is also called the "Linked
Version".
The "Minimal Corresponding Source" for a Combined Work means the
Corresponding Source for the Combined Work, excluding any source code
for portions of the Combined Work that, considered in isolation, are
based on the Application, and not on the Linked Version.
The "Corresponding Application Code" for a Combined Work means the
object code and/or source code for the Application, including any data
and utility programs needed for reproducing the Combined Work from the
Application, but excluding the System Libraries of the Combined Work.
1. Exception to Section 3 of the GNU GPL.
You may convey a covered work under sections 3 and 4 of this License
without being bound by section 3 of the GNU GPL.
2. Conveying Modified Versions.
If you modify a copy of the Library, and, in your modifications, a
facility refers to a function or data to be supplied by an Application
that uses the facility (other than as an argument passed when the
facility is invoked), then you may convey a copy of the modified
version:
a) under this License, provided that you make a good faith effort to
ensure that, in the event an Application does not supply the
function or data, the facility still operates, and performs
whatever part of its purpose remains meaningful, or
b) under the GNU GPL, with none of the additional permissions of
this License applicable to that copy.
3. Object Code Incorporating Material from Library Header Files.
The object code form of an Application may incorporate material from
a header file that is part of the Library. You may convey such object
code under terms of your choice, provided that, if the incorporated
material is not limited to numerical parameters, data structure
layouts and accessors, or small macros, inline functions and templates
(ten or fewer lines in length), you do both of the following:
a) Give prominent notice with each copy of the object code that the
Library is used in it and that the Library and its use are
covered by this License.
b) Accompany the object code with a copy of the GNU GPL and this license
document.
4. Combined Works.
You may convey a Combined Work under terms of your choice that,
taken together, effectively do not restrict modification of the
portions of the Library contained in the Combined Work and reverse
engineering for debugging such modifications, if you also do each of
the following:
a) Give prominent notice with each copy of the Combined Work that
the Library is used in it and that the Library and its use are
covered by this License.
b) Accompany the Combined Work with a copy of the GNU GPL and this license
document.
c) For a Combined Work that displays copyright notices during
execution, include the copyright notice for the Library among
these notices, as well as a reference directing the user to the
copies of the GNU GPL and this license document.
d) Do one of the following:
0) Convey the Minimal Corresponding Source under the terms of this
License, and the Corresponding Application Code in a form
suitable for, and under terms that permit, the user to
recombine or relink the Application with a modified version of
the Linked Version to produce a modified Combined Work, in the
manner specified by section 6 of the GNU GPL for conveying
Corresponding Source.
1) Use a suitable shared library mechanism for linking with the
Library. A suitable mechanism is one that (a) uses at run time
a copy of the Library already present on the user's computer
system, and (b) will operate properly with a modified version
of the Library that is interface-compatible with the Linked
Version.
e) Provide Installation Information, but only if you would otherwise
be required to provide such information under section 6 of the
GNU GPL, and only to the extent that such information is
necessary to install and execute a modified version of the
Combined Work produced by recombining or relinking the
Application with a modified version of the Linked Version. (If
you use option 4d0, the Installation Information must accompany
the Minimal Corresponding Source and Corresponding Application
Code. If you use option 4d1, you must provide the Installation
Information in the manner specified by section 6 of the GNU GPL
for conveying Corresponding Source.)
5. Combined Libraries.
You may place library facilities that are a work based on the
Library side by side in a single library together with other library
facilities that are not Applications and are not covered by this
License, and convey such a combined library under terms of your
choice, if you do both of the following:
a) Accompany the combined library with a copy of the same work based
on the Library, uncombined with any other library facilities,
conveyed under the terms of this License.
b) Give prominent notice with the combined library that part of it
is a work based on the Library, and explaining where to find the
accompanying uncombined form of the same work.
6. Revised Versions of the GNU Lesser General Public License.
The Free Software Foundation may publish revised and/or new versions
of the GNU Lesser General Public License from time to time. Such new
versions will be similar in spirit to the present version, but may
differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the
Library as you received it specifies that a certain numbered version
of the GNU Lesser General Public License "or any later version"
applies to it, you have the option of following the terms and
conditions either of that published version or of any later version
published by the Free Software Foundation. If the Library as you
received it does not specify a version number of the GNU Lesser
General Public License, you may choose any version of the GNU Lesser
General Public License ever published by the Free Software Foundation.
If the Library as you received it specifies that a proxy can decide
whether future versions of the GNU Lesser General Public License shall
apply, that proxy's public statement of acceptance of any version is
permanent authorization for you to choose that version for the
Library.

18
vendor/github.com/ngaut/log/crash_darwin.go generated vendored
View file

@ -1,18 +0,0 @@
// +build darwin
package log
import (
"log"
"os"
"syscall"
)
func CrashLog(file string) {
f, err := os.OpenFile(file, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666)
if err != nil {
log.Println(err.Error())
} else {
syscall.Dup2(int(f.Fd()), 2)
}
}

18
vendor/github.com/ngaut/log/crash_unix.go generated vendored
View file

@ -1,18 +0,0 @@
// +build freebsd openbsd netbsd dragonfly linux
package log
import (
"log"
"os"
"syscall"
)
func CrashLog(file string) {
f, err := os.OpenFile(file, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666)
if err != nil {
log.Println(err.Error())
} else {
syscall.Dup3(int(f.Fd()), 2, 0)
}
}

37
vendor/github.com/ngaut/log/crash_win.go generated vendored
View file

@ -1,37 +0,0 @@
// +build windows
package log
import (
"log"
"os"
"syscall"
)
var (
kernel32 = syscall.MustLoadDLL("kernel32.dll")
procSetStdHandle = kernel32.MustFindProc("SetStdHandle")
)
func setStdHandle(stdhandle int32, handle syscall.Handle) error {
r0, _, e1 := syscall.Syscall(procSetStdHandle.Addr(), 2, uintptr(stdhandle), uintptr(handle), 0)
if r0 == 0 {
if e1 != 0 {
return error(e1)
}
return syscall.EINVAL
}
return nil
}
func CrashLog(file string) {
f, err := os.OpenFile(file, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666)
if err != nil {
log.Println(err.Error())
} else {
err = setStdHandle(syscall.STD_ERROR_HANDLE, syscall.Handle(f.Fd()))
if err != nil {
log.Println(err.Error())
}
}
}

380
vendor/github.com/ngaut/log/log.go generated vendored
View file

@ -1,380 +0,0 @@
//high level log wrapper, so it can output different log based on level
package log
import (
"fmt"
"io"
"log"
"os"
"runtime"
"sync"
"time"
)
const (
Ldate = log.Ldate
Llongfile = log.Llongfile
Lmicroseconds = log.Lmicroseconds
Lshortfile = log.Lshortfile
LstdFlags = log.LstdFlags
Ltime = log.Ltime
)
type (
LogLevel int
LogType int
)
const (
LOG_FATAL = LogType(0x1)
LOG_ERROR = LogType(0x2)
LOG_WARNING = LogType(0x4)
LOG_INFO = LogType(0x8)
LOG_DEBUG = LogType(0x10)
)
const (
LOG_LEVEL_NONE = LogLevel(0x0)
LOG_LEVEL_FATAL = LOG_LEVEL_NONE | LogLevel(LOG_FATAL)
LOG_LEVEL_ERROR = LOG_LEVEL_FATAL | LogLevel(LOG_ERROR)
LOG_LEVEL_WARN = LOG_LEVEL_ERROR | LogLevel(LOG_WARNING)
LOG_LEVEL_INFO = LOG_LEVEL_WARN | LogLevel(LOG_INFO)
LOG_LEVEL_DEBUG = LOG_LEVEL_INFO | LogLevel(LOG_DEBUG)
LOG_LEVEL_ALL = LOG_LEVEL_DEBUG
)
const FORMAT_TIME_DAY string = "20060102"
const FORMAT_TIME_HOUR string = "2006010215"
var _log *logger = New()
func init() {
SetFlags(Ldate | Ltime | Lshortfile)
SetHighlighting(runtime.GOOS != "windows")
}
func Logger() *log.Logger {
return _log._log
}
func SetLevel(level LogLevel) {
_log.SetLevel(level)
}
func GetLogLevel() LogLevel {
return _log.level
}
func SetOutput(out io.Writer) {
_log.SetOutput(out)
}
func SetOutputByName(path string) error {
return _log.SetOutputByName(path)
}
func SetFlags(flags int) {
_log._log.SetFlags(flags)
}
func Info(v ...interface{}) {
_log.Info(v...)
}
func Infof(format string, v ...interface{}) {
_log.Infof(format, v...)
}
func Debug(v ...interface{}) {
_log.Debug(v...)
}
func Debugf(format string, v ...interface{}) {
_log.Debugf(format, v...)
}
func Warn(v ...interface{}) {
_log.Warning(v...)
}
func Warnf(format string, v ...interface{}) {
_log.Warningf(format, v...)
}
func Warning(v ...interface{}) {
_log.Warning(v...)
}
func Warningf(format string, v ...interface{}) {
_log.Warningf(format, v...)
}
func Error(v ...interface{}) {
_log.Error(v...)
}
func Errorf(format string, v ...interface{}) {
_log.Errorf(format, v...)
}
func Fatal(v ...interface{}) {
_log.Fatal(v...)
}
func Fatalf(format string, v ...interface{}) {
_log.Fatalf(format, v...)
}
func SetLevelByString(level string) {
_log.SetLevelByString(level)
}
func SetHighlighting(highlighting bool) {
_log.SetHighlighting(highlighting)
}
func SetRotateByDay() {
_log.SetRotateByDay()
}
func SetRotateByHour() {
_log.SetRotateByHour()
}
type logger struct {
_log *log.Logger
level LogLevel
highlighting bool
dailyRolling bool
hourRolling bool
fileName string
logSuffix string
fd *os.File
lock sync.Mutex
}
func (l *logger) SetHighlighting(highlighting bool) {
l.highlighting = highlighting
}
func (l *logger) SetLevel(level LogLevel) {
l.level = level
}
func (l *logger) SetLevelByString(level string) {
l.level = StringToLogLevel(level)
}
func (l *logger) SetRotateByDay() {
l.dailyRolling = true
l.logSuffix = genDayTime(time.Now())
}
func (l *logger) SetRotateByHour() {
l.hourRolling = true
l.logSuffix = genHourTime(time.Now())
}
func (l *logger) rotate() error {
l.lock.Lock()
defer l.lock.Unlock()
var suffix string
if l.dailyRolling {
suffix = genDayTime(time.Now())
} else if l.hourRolling {
suffix = genHourTime(time.Now())
} else {
return nil
}
// Notice: if suffix is not equal to l.LogSuffix, then rotate
if suffix != l.logSuffix {
err := l.doRotate(suffix)
if err != nil {
return err
}
}
return nil
}
func (l *logger) doRotate(suffix string) error {
// Notice: Not check error, is this ok?
l.fd.Close()
lastFileName := l.fileName + "." + l.logSuffix
err := os.Rename(l.fileName, lastFileName)
if err != nil {
return err
}
err = l.SetOutputByName(l.fileName)
if err != nil {
return err
}
l.logSuffix = suffix
return nil
}
func (l *logger) SetOutput(out io.Writer) {
l._log = log.New(out, l._log.Prefix(), l._log.Flags())
}
func (l *logger) SetOutputByName(path string) error {
f, err := os.OpenFile(path, os.O_CREATE|os.O_APPEND|os.O_RDWR, 0666)
if err != nil {
log.Fatal(err)
}
l.SetOutput(f)
l.fileName = path
l.fd = f
return err
}
func (l *logger) log(t LogType, v ...interface{}) {
if l.level|LogLevel(t) != l.level {
return
}
err := l.rotate()
if err != nil {
fmt.Fprintf(os.Stderr, "%s\n", err.Error())
return
}
v1 := make([]interface{}, len(v)+2)
logStr, logColor := LogTypeToString(t)
if l.highlighting {
v1[0] = "\033" + logColor + "m[" + logStr + "]"
copy(v1[1:], v)
v1[len(v)+1] = "\033[0m"
} else {
v1[0] = "[" + logStr + "]"
copy(v1[1:], v)
v1[len(v)+1] = ""
}
s := fmt.Sprintln(v1...)
l._log.Output(4, s)
}
func (l *logger) logf(t LogType, format string, v ...interface{}) {
if l.level|LogLevel(t) != l.level {
return
}
err := l.rotate()
if err != nil {
fmt.Fprintf(os.Stderr, "%s\n", err.Error())
return
}
logStr, logColor := LogTypeToString(t)
var s string
if l.highlighting {
s = "\033" + logColor + "m[" + logStr + "] " + fmt.Sprintf(format, v...) + "\033[0m"
} else {
s = "[" + logStr + "] " + fmt.Sprintf(format, v...)
}
l._log.Output(4, s)
}
func (l *logger) Fatal(v ...interface{}) {
l.log(LOG_FATAL, v...)
os.Exit(-1)
}
func (l *logger) Fatalf(format string, v ...interface{}) {
l.logf(LOG_FATAL, format, v...)
os.Exit(-1)
}
func (l *logger) Error(v ...interface{}) {
l.log(LOG_ERROR, v...)
}
func (l *logger) Errorf(format string, v ...interface{}) {
l.logf(LOG_ERROR, format, v...)
}
func (l *logger) Warning(v ...interface{}) {
l.log(LOG_WARNING, v...)
}
func (l *logger) Warningf(format string, v ...interface{}) {
l.logf(LOG_WARNING, format, v...)
}
func (l *logger) Debug(v ...interface{}) {
l.log(LOG_DEBUG, v...)
}
func (l *logger) Debugf(format string, v ...interface{}) {
l.logf(LOG_DEBUG, format, v...)
}
func (l *logger) Info(v ...interface{}) {
l.log(LOG_INFO, v...)
}
func (l *logger) Infof(format string, v ...interface{}) {
l.logf(LOG_INFO, format, v...)
}
func StringToLogLevel(level string) LogLevel {
switch level {
case "fatal":
return LOG_LEVEL_FATAL
case "error":
return LOG_LEVEL_ERROR
case "warn":
return LOG_LEVEL_WARN
case "warning":
return LOG_LEVEL_WARN
case "debug":
return LOG_LEVEL_DEBUG
case "info":
return LOG_LEVEL_INFO
}
return LOG_LEVEL_ALL
}
func LogTypeToString(t LogType) (string, string) {
switch t {
case LOG_FATAL:
return "fatal", "[0;31"
case LOG_ERROR:
return "error", "[0;31"
case LOG_WARNING:
return "warning", "[0;33"
case LOG_DEBUG:
return "debug", "[0;36"
case LOG_INFO:
return "info", "[0;37"
}
return "unknown", "[0;37"
}
func genDayTime(t time.Time) string {
return t.Format(FORMAT_TIME_DAY)
}
func genHourTime(t time.Time) string {
return t.Format(FORMAT_TIME_HOUR)
}
func New() *logger {
return Newlogger(os.Stderr, "")
}
func Newlogger(w io.Writer, prefix string) *logger {
return &logger{_log: log.New(w, prefix, LstdFlags), level: LOG_LEVEL_ALL, highlighting: true}
}

72
vendor/github.com/ngaut/pools/id_pool.go generated vendored
View file

@ -1,72 +0,0 @@
// Copyright 2014, Google Inc. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package pools
import (
"fmt"
"sync"
)
// IDPool is used to ensure that the set of IDs in use concurrently never
// contains any duplicates. The IDs start at 1 and increase without bound, but
// will never be larger than the peak number of concurrent uses.
//
// IDPool's Get() and Set() methods can be used concurrently.
type IDPool struct {
sync.Mutex
// used holds the set of values that have been returned to us with Put().
used map[uint32]bool
// maxUsed remembers the largest value we've given out.
maxUsed uint32
}
// NewIDPool creates and initializes an IDPool.
func NewIDPool() *IDPool {
return &IDPool{
used: make(map[uint32]bool),
}
}
// Get returns an ID that is unique among currently active users of this pool.
func (pool *IDPool) Get() (id uint32) {
pool.Lock()
defer pool.Unlock()
// Pick a value that's been returned, if any.
for key, _ := range pool.used {
delete(pool.used, key)
return key
}
// No recycled IDs are available, so increase the pool size.
pool.maxUsed += 1
return pool.maxUsed
}
// Put recycles an ID back into the pool for others to use. Putting back a value
// or 0, or a value that is not currently "checked out", will result in a panic
// because that should never happen except in the case of a programming error.
func (pool *IDPool) Put(id uint32) {
pool.Lock()
defer pool.Unlock()
if id < 1 || id > pool.maxUsed {
panic(fmt.Errorf("IDPool.Put(%v): invalid value, must be in the range [1,%v]", id, pool.maxUsed))
}
if pool.used[id] {
panic(fmt.Errorf("IDPool.Put(%v): can't put value that was already recycled", id))
}
// If we're recycling maxUsed, just shrink the pool.
if id == pool.maxUsed {
pool.maxUsed = id - 1
return
}
// Add it to the set of recycled IDs.
pool.used[id] = true
}

149
vendor/github.com/ngaut/pools/numbered.go generated vendored
View file

@ -1,149 +0,0 @@
// Copyright 2012, Google Inc. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package pools
import (
"fmt"
"sync"
"time"
)
// Numbered allows you to manage resources by tracking them with numbers.
// There are no interface restrictions on what you can track.
type Numbered struct {
mu sync.Mutex
empty *sync.Cond // Broadcast when pool becomes empty
resources map[int64]*numberedWrapper
}
type numberedWrapper struct {
val interface{}
inUse bool
purpose string
timeCreated time.Time
timeUsed time.Time
}
func NewNumbered() *Numbered {
n := &Numbered{resources: make(map[int64]*numberedWrapper)}
n.empty = sync.NewCond(&n.mu)
return n
}
// Register starts tracking a resource by the supplied id.
// It does not lock the object.
// It returns an error if the id already exists.
func (nu *Numbered) Register(id int64, val interface{}) error {
nu.mu.Lock()
defer nu.mu.Unlock()
if _, ok := nu.resources[id]; ok {
return fmt.Errorf("already present")
}
now := time.Now()
nu.resources[id] = &numberedWrapper{
val: val,
timeCreated: now,
timeUsed: now,
}
return nil
}
// Unregiester forgets the specified resource.
// If the resource is not present, it's ignored.
func (nu *Numbered) Unregister(id int64) {
nu.mu.Lock()
defer nu.mu.Unlock()
delete(nu.resources, id)
if len(nu.resources) == 0 {
nu.empty.Broadcast()
}
}
// Get locks the resource for use. It accepts a purpose as a string.
// If it cannot be found, it returns a "not found" error. If in use,
// it returns a "in use: purpose" error.
func (nu *Numbered) Get(id int64, purpose string) (val interface{}, err error) {
nu.mu.Lock()
defer nu.mu.Unlock()
nw, ok := nu.resources[id]
if !ok {
return nil, fmt.Errorf("not found")
}
if nw.inUse {
return nil, fmt.Errorf("in use: %s", nw.purpose)
}
nw.inUse = true
nw.purpose = purpose
return nw.val, nil
}
// Put unlocks a resource for someone else to use.
func (nu *Numbered) Put(id int64) {
nu.mu.Lock()
defer nu.mu.Unlock()
if nw, ok := nu.resources[id]; ok {
nw.inUse = false
nw.purpose = ""
nw.timeUsed = time.Now()
}
}
// GetOutdated returns a list of resources that are older than age, and locks them.
// It does not return any resources that are already locked.
func (nu *Numbered) GetOutdated(age time.Duration, purpose string) (vals []interface{}) {
nu.mu.Lock()
defer nu.mu.Unlock()
now := time.Now()
for _, nw := range nu.resources {
if nw.inUse {
continue
}
if nw.timeCreated.Add(age).Sub(now) <= 0 {
nw.inUse = true
nw.purpose = purpose
vals = append(vals, nw.val)
}
}
return vals
}
// GetIdle returns a list of resurces that have been idle for longer
// than timeout, and locks them. It does not return any resources that
// are already locked.
func (nu *Numbered) GetIdle(timeout time.Duration, purpose string) (vals []interface{}) {
nu.mu.Lock()
defer nu.mu.Unlock()
now := time.Now()
for _, nw := range nu.resources {
if nw.inUse {
continue
}
if nw.timeUsed.Add(timeout).Sub(now) <= 0 {
nw.inUse = true
nw.purpose = purpose
vals = append(vals, nw.val)
}
}
return vals
}
// WaitForEmpty returns as soon as the pool becomes empty
func (nu *Numbered) WaitForEmpty() {
nu.mu.Lock()
defer nu.mu.Unlock()
for len(nu.resources) != 0 {
nu.empty.Wait()
}
}
func (nu *Numbered) StatsJSON() string {
return fmt.Sprintf("{\"Size\": %v}", nu.Size())
}
func (nu *Numbered) Size() (size int64) {
nu.mu.Lock()
defer nu.mu.Unlock()
return int64(len(nu.resources))
}

228
vendor/github.com/ngaut/pools/resource_pool.go generated vendored
View file

@ -1,228 +0,0 @@
// Copyright 2012, Google Inc. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Package pools provides functionality to manage and reuse resources
// like connections.
package pools
import (
"fmt"
"time"
"github.com/ngaut/sync2"
)
var (
CLOSED_ERR = fmt.Errorf("ResourcePool is closed")
)
// Factory is a function that can be used to create a resource.
type Factory func() (Resource, error)
// Every resource needs to suport the Resource interface.
// Thread synchronization between Close() and IsClosed()
// is the responsibility the caller.
type Resource interface {
Close()
}
// ResourcePool allows you to use a pool of resources.
type ResourcePool struct {
resources chan resourceWrapper
factory Factory
capacity sync2.AtomicInt64
idleTimeout sync2.AtomicDuration
// stats
waitCount sync2.AtomicInt64
waitTime sync2.AtomicDuration
}
type resourceWrapper struct {
resource Resource
timeUsed time.Time
}
// NewResourcePool creates a new ResourcePool pool.
// capacity is the initial capacity of the pool.
// maxCap is the maximum capacity.
// If a resource is unused beyond idleTimeout, it's discarded.
// An idleTimeout of 0 means that there is no timeout.
func NewResourcePool(factory Factory, capacity, maxCap int, idleTimeout time.Duration) *ResourcePool {
if capacity <= 0 || maxCap <= 0 || capacity > maxCap {
panic(fmt.Errorf("Invalid/out of range capacity"))
}
rp := &ResourcePool{
resources: make(chan resourceWrapper, maxCap),
factory: factory,
capacity: sync2.AtomicInt64(capacity),
idleTimeout: sync2.AtomicDuration(idleTimeout),
}
for i := 0; i < capacity; i++ {
rp.resources <- resourceWrapper{}
}
return rp
}
// Close empties the pool calling Close on all its resources.
// You can call Close while there are outstanding resources.
// It waits for all resources to be returned (Put).
// After a Close, Get and TryGet are not allowed.
func (rp *ResourcePool) Close() {
rp.SetCapacity(0)
}
func (rp *ResourcePool) IsClosed() (closed bool) {
return rp.capacity.Get() == 0
}
// Get will return the next available resource. If capacity
// has not been reached, it will create a new one using the factory. Otherwise,
// it will indefinitely wait till the next resource becomes available.
func (rp *ResourcePool) Get() (resource Resource, err error) {
return rp.get(true)
}
// TryGet will return the next available resource. If none is available, and capacity
// has not been reached, it will create a new one using the factory. Otherwise,
// it will return nil with no error.
func (rp *ResourcePool) TryGet() (resource Resource, err error) {
return rp.get(false)
}
func (rp *ResourcePool) get(wait bool) (resource Resource, err error) {
// Fetch
var wrapper resourceWrapper
var ok bool
select {
case wrapper, ok = <-rp.resources:
default:
if !wait {
return nil, nil
}
startTime := time.Now()
wrapper, ok = <-rp.resources
rp.recordWait(startTime)
}
if !ok {
return nil, CLOSED_ERR
}
// Unwrap
timeout := rp.idleTimeout.Get()
if wrapper.resource != nil && timeout > 0 && wrapper.timeUsed.Add(timeout).Sub(time.Now()) < 0 {
wrapper.resource.Close()
wrapper.resource = nil
}
if wrapper.resource == nil {
wrapper.resource, err = rp.factory()
if err != nil {
rp.resources <- resourceWrapper{}
}
}
return wrapper.resource, err
}
// Put will return a resource to the pool. For every successful Get,
// a corresponding Put is required. If you no longer need a resource,
// you will need to call Put(nil) instead of returning the closed resource.
// The will eventually cause a new resource to be created in its place.
func (rp *ResourcePool) Put(resource Resource) {
var wrapper resourceWrapper
if resource != nil {
wrapper = resourceWrapper{resource, time.Now()}
}
select {
case rp.resources <- wrapper:
default:
panic(fmt.Errorf("Attempt to Put into a full ResourcePool"))
}
}
// SetCapacity changes the capacity of the pool.
// You can use it to shrink or expand, but not beyond
// the max capacity. If the change requires the pool
// to be shrunk, SetCapacity waits till the necessary
// number of resources are returned to the pool.
// A SetCapacity of 0 is equivalent to closing the ResourcePool.
func (rp *ResourcePool) SetCapacity(capacity int) error {
if capacity < 0 || capacity > cap(rp.resources) {
return fmt.Errorf("capacity %d is out of range", capacity)
}
// Atomically swap new capacity with old, but only
// if old capacity is non-zero.
var oldcap int
for {
oldcap = int(rp.capacity.Get())
if oldcap == 0 {
return CLOSED_ERR
}
if oldcap == capacity {
return nil
}
if rp.capacity.CompareAndSwap(int64(oldcap), int64(capacity)) {
break
}
}
if capacity < oldcap {
for i := 0; i < oldcap-capacity; i++ {
wrapper := <-rp.resources
if wrapper.resource != nil {
wrapper.resource.Close()
}
}
} else {
for i := 0; i < capacity-oldcap; i++ {
rp.resources <- resourceWrapper{}
}
}
if capacity == 0 {
close(rp.resources)
}
return nil
}
func (rp *ResourcePool) recordWait(start time.Time) {
rp.waitCount.Add(1)
rp.waitTime.Add(time.Now().Sub(start))
}
func (rp *ResourcePool) SetIdleTimeout(idleTimeout time.Duration) {
rp.idleTimeout.Set(idleTimeout)
}
func (rp *ResourcePool) StatsJSON() string {
c, a, mx, wc, wt, it := rp.Stats()
return fmt.Sprintf(`{"Capacity": %v, "Available": %v, "MaxCapacity": %v, "WaitCount": %v, "WaitTime": %v, "IdleTimeout": %v}`, c, a, mx, wc, int64(wt), int64(it))
}
func (rp *ResourcePool) Stats() (capacity, available, maxCap, waitCount int64, waitTime, idleTimeout time.Duration) {
return rp.Capacity(), rp.Available(), rp.MaxCap(), rp.WaitCount(), rp.WaitTime(), rp.IdleTimeout()
}
func (rp *ResourcePool) Capacity() int64 {
return rp.capacity.Get()
}
func (rp *ResourcePool) Available() int64 {
return int64(len(rp.resources))
}
func (rp *ResourcePool) MaxCap() int64 {
return int64(cap(rp.resources))
}
func (rp *ResourcePool) WaitCount() int64 {
return rp.waitCount.Get()
}
func (rp *ResourcePool) WaitTime() time.Duration {
return rp.waitTime.Get()
}
func (rp *ResourcePool) IdleTimeout() time.Duration {
return rp.idleTimeout.Get()
}

214
vendor/github.com/ngaut/pools/roundrobin.go generated vendored
View file

@ -1,214 +0,0 @@
// Copyright 2012, Google Inc. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package pools
import (
"fmt"
"sync"
"time"
)
// RoundRobin is deprecated. Use ResourcePool instead.
// RoundRobin allows you to use a pool of resources in a round robin fashion.
type RoundRobin struct {
mu sync.Mutex
available *sync.Cond
resources chan fifoWrapper
size int64
factory Factory
idleTimeout time.Duration
// stats
waitCount int64
waitTime time.Duration
}
type fifoWrapper struct {
resource Resource
timeUsed time.Time
}
// NewRoundRobin creates a new RoundRobin pool.
// capacity is the maximum number of resources RoundRobin will create.
// factory will be the function used to create resources.
// If a resource is unused beyond idleTimeout, it's discarded.
func NewRoundRobin(capacity int, idleTimeout time.Duration) *RoundRobin {
r := &RoundRobin{
resources: make(chan fifoWrapper, capacity),
size: 0,
idleTimeout: idleTimeout,
}
r.available = sync.NewCond(&r.mu)
return r
}
// Open starts allowing the creation of resources
func (rr *RoundRobin) Open(factory Factory) {
rr.mu.Lock()
defer rr.mu.Unlock()
rr.factory = factory
}
// Close empties the pool calling Close on all its resources.
// It waits for all resources to be returned (Put).
func (rr *RoundRobin) Close() {
rr.mu.Lock()
defer rr.mu.Unlock()
for rr.size > 0 {
select {
case fw := <-rr.resources:
go fw.resource.Close()
rr.size--
default:
rr.available.Wait()
}
}
rr.factory = nil
}
func (rr *RoundRobin) IsClosed() bool {
return rr.factory == nil
}
// Get will return the next available resource. If none is available, and capacity
// has not been reached, it will create a new one using the factory. Otherwise,
// it will indefinitely wait till the next resource becomes available.
func (rr *RoundRobin) Get() (resource Resource, err error) {
return rr.get(true)
}
// TryGet will return the next available resource. If none is available, and capacity
// has not been reached, it will create a new one using the factory. Otherwise,
// it will return nil with no error.
func (rr *RoundRobin) TryGet() (resource Resource, err error) {
return rr.get(false)
}
func (rr *RoundRobin) get(wait bool) (resource Resource, err error) {
rr.mu.Lock()
defer rr.mu.Unlock()
// Any waits in this loop will release the lock, and it will be
// reacquired before the waits return.
for {
select {
case fw := <-rr.resources:
// Found a free resource in the channel
if rr.idleTimeout > 0 && fw.timeUsed.Add(rr.idleTimeout).Sub(time.Now()) < 0 {
// resource has been idle for too long. Discard & go for next.
go fw.resource.Close()
rr.size--
// Nobody else should be waiting, but signal anyway.
rr.available.Signal()
continue
}
return fw.resource, nil
default:
// resource channel is empty
if rr.size >= int64(cap(rr.resources)) {
// The pool is full
if wait {
start := time.Now()
rr.available.Wait()
rr.recordWait(start)
continue
}
return nil, nil
}
// Pool is not full. Create a resource.
if resource, err = rr.waitForCreate(); err != nil {
// size was decremented, and somebody could be waiting.
rr.available.Signal()
return nil, err
}
// Creation successful. Account for this by incrementing size.
rr.size++
return resource, err
}
}
}
func (rr *RoundRobin) recordWait(start time.Time) {
rr.waitCount++
rr.waitTime += time.Now().Sub(start)
}
func (rr *RoundRobin) waitForCreate() (resource Resource, err error) {
// Prevent thundering herd: increment size before creating resource, and decrement after.
rr.size++
rr.mu.Unlock()
defer func() {
rr.mu.Lock()
rr.size--
}()
return rr.factory()
}
// Put will return a resource to the pool. You MUST return every resource to the pool,
// even if it's closed. If a resource is closed, you should call Put(nil).
func (rr *RoundRobin) Put(resource Resource) {
rr.mu.Lock()
defer rr.available.Signal()
defer rr.mu.Unlock()
if rr.size > int64(cap(rr.resources)) {
if resource != nil {
go resource.Close()
}
rr.size--
} else if resource == nil {
rr.size--
} else {
if len(rr.resources) == cap(rr.resources) {
panic("unexpected")
}
rr.resources <- fifoWrapper{resource, time.Now()}
}
}
// Set capacity changes the capacity of the pool.
// You can use it to expand or shrink.
func (rr *RoundRobin) SetCapacity(capacity int) error {
rr.mu.Lock()
defer rr.available.Broadcast()
defer rr.mu.Unlock()
nr := make(chan fifoWrapper, capacity)
// This loop transfers resources from the old channel
// to the new one, until it fills up or runs out.
// It discards extras, if any.
for {
select {
case fw := <-rr.resources:
if len(nr) < cap(nr) {
nr <- fw
} else {
go fw.resource.Close()
rr.size--
}
continue
default:
}
break
}
rr.resources = nr
return nil
}
func (rr *RoundRobin) SetIdleTimeout(idleTimeout time.Duration) {
rr.mu.Lock()
defer rr.mu.Unlock()
rr.idleTimeout = idleTimeout
}
func (rr *RoundRobin) StatsJSON() string {
s, c, a, wc, wt, it := rr.Stats()
return fmt.Sprintf("{\"Size\": %v, \"Capacity\": %v, \"Available\": %v, \"WaitCount\": %v, \"WaitTime\": %v, \"IdleTimeout\": %v}", s, c, a, wc, int64(wt), int64(it))
}
func (rr *RoundRobin) Stats() (size, capacity, available, waitCount int64, waitTime, idleTimeout time.Duration) {
rr.mu.Lock()
defer rr.mu.Unlock()
return rr.size, int64(cap(rr.resources)), int64(len(rr.resources)), rr.waitCount, rr.waitTime, rr.idleTimeout
}

114
vendor/github.com/ngaut/sync2/atomic.go generated vendored
View file

@ -1,114 +0,0 @@
// Copyright 2013, Google Inc. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package sync2
import (
"sync"
"sync/atomic"
"time"
)
type AtomicInt32 int32
func (i *AtomicInt32) Add(n int32) int32 {
return atomic.AddInt32((*int32)(i), n)
}
func (i *AtomicInt32) Set(n int32) {
atomic.StoreInt32((*int32)(i), n)
}
func (i *AtomicInt32) Get() int32 {
return atomic.LoadInt32((*int32)(i))
}
func (i *AtomicInt32) CompareAndSwap(oldval, newval int32) (swapped bool) {
return atomic.CompareAndSwapInt32((*int32)(i), oldval, newval)
}
type AtomicUint32 uint32
func (i *AtomicUint32) Add(n uint32) uint32 {
return atomic.AddUint32((*uint32)(i), n)
}
func (i *AtomicUint32) Set(n uint32) {
atomic.StoreUint32((*uint32)(i), n)
}
func (i *AtomicUint32) Get() uint32 {
return atomic.LoadUint32((*uint32)(i))
}
func (i *AtomicUint32) CompareAndSwap(oldval, newval uint32) (swapped bool) {
return atomic.CompareAndSwapUint32((*uint32)(i), oldval, newval)
}
type AtomicInt64 int64
func (i *AtomicInt64) Add(n int64) int64 {
return atomic.AddInt64((*int64)(i), n)
}
func (i *AtomicInt64) Set(n int64) {
atomic.StoreInt64((*int64)(i), n)
}
func (i *AtomicInt64) Get() int64 {
return atomic.LoadInt64((*int64)(i))
}
func (i *AtomicInt64) CompareAndSwap(oldval, newval int64) (swapped bool) {
return atomic.CompareAndSwapInt64((*int64)(i), oldval, newval)
}
type AtomicDuration int64
func (d *AtomicDuration) Add(duration time.Duration) time.Duration {
return time.Duration(atomic.AddInt64((*int64)(d), int64(duration)))
}
func (d *AtomicDuration) Set(duration time.Duration) {
atomic.StoreInt64((*int64)(d), int64(duration))
}
func (d *AtomicDuration) Get() time.Duration {
return time.Duration(atomic.LoadInt64((*int64)(d)))
}
func (d *AtomicDuration) CompareAndSwap(oldval, newval time.Duration) (swapped bool) {
return atomic.CompareAndSwapInt64((*int64)(d), int64(oldval), int64(newval))
}
// AtomicString gives you atomic-style APIs for string, but
// it's only a convenience wrapper that uses a mutex. So, it's
// not as efficient as the rest of the atomic types.
type AtomicString struct {
mu sync.Mutex
str string
}
func (s *AtomicString) Set(str string) {
s.mu.Lock()
s.str = str
s.mu.Unlock()
}
func (s *AtomicString) Get() string {
s.mu.Lock()
str := s.str
s.mu.Unlock()
return str
}
func (s *AtomicString) CompareAndSwap(oldval, newval string) (swqpped bool) {
s.mu.Lock()
defer s.mu.Unlock()
if s.str == oldval {
s.str = newval
return true
}
return false
}

56
vendor/github.com/ngaut/sync2/cond.go generated vendored
View file

@ -1,56 +0,0 @@
// Copyright 2013, Google Inc. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package sync2
import (
"sync"
)
// Cond is an alternate implementation of sync.Cond
type Cond struct {
L sync.Locker
sema chan struct{}
waiters AtomicInt64
}
func NewCond(l sync.Locker) *Cond {
return &Cond{L: l, sema: make(chan struct{})}
}
func (c *Cond) Wait() {
c.waiters.Add(1)
c.L.Unlock()
<-c.sema
c.L.Lock()
}
func (c *Cond) Signal() {
for {
w := c.waiters.Get()
if w == 0 {
return
}
if c.waiters.CompareAndSwap(w, w-1) {
break
}
}
c.sema <- struct{}{}
}
func (c *Cond) Broadcast() {
var w int64
for {
w = c.waiters.Get()
if w == 0 {
return
}
if c.waiters.CompareAndSwap(w, 0) {
break
}
}
for i := int64(0); i < w; i++ {
c.sema <- struct{}{}
}
}

55
vendor/github.com/ngaut/sync2/semaphore.go generated vendored
View file

@ -1,55 +0,0 @@
// Copyright 2012, Google Inc. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package sync2
// What's in a name? Channels have all you need to emulate a counting
// semaphore with a boatload of extra functionality. However, in some
// cases, you just want a familiar API.
import (
"time"
)
// Semaphore is a counting semaphore with the option to
// specify a timeout.
type Semaphore struct {
slots chan struct{}
timeout time.Duration
}
// NewSemaphore creates a Semaphore. The count parameter must be a positive
// number. A timeout of zero means that there is no timeout.
func NewSemaphore(count int, timeout time.Duration) *Semaphore {
sem := &Semaphore{
slots: make(chan struct{}, count),
timeout: timeout,
}
for i := 0; i < count; i++ {
sem.slots <- struct{}{}
}
return sem
}
// Acquire returns true on successful acquisition, and
// false on a timeout.
func (sem *Semaphore) Acquire() bool {
if sem.timeout == 0 {
<-sem.slots
return true
}
select {
case <-sem.slots:
return true
case <-time.After(sem.timeout):
return false
}
}
// Release releases the acquired semaphore. You must
// not release more than the number of semaphores you've
// acquired.
func (sem *Semaphore) Release() {
sem.slots <- struct{}{}
}

121
vendor/github.com/ngaut/sync2/service_manager.go generated vendored
View file

@ -1,121 +0,0 @@
// Copyright 2013, Google Inc. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package sync2
import (
"sync"
)
// These are the three predefined states of a service.
const (
SERVICE_STOPPED = iota
SERVICE_RUNNING
SERVICE_SHUTTING_DOWN
)
var stateNames = []string{
"Stopped",
"Running",
"ShuttingDown",
}
// ServiceManager manages the state of a service through its lifecycle.
type ServiceManager struct {
mu sync.Mutex
wg sync.WaitGroup
err error // err is the error returned from the service function.
state AtomicInt64
// shutdown is created when the service starts and is closed when the service
// enters the SERVICE_SHUTTING_DOWN state.
shutdown chan struct{}
}
// Go tries to change the state from SERVICE_STOPPED to SERVICE_RUNNING.
//
// If the current state is not SERVICE_STOPPED (already running), it returns
// false immediately.
//
// On successful transition, it launches the service as a goroutine and returns
// true. The service function is responsible for returning on its own when
// requested, either by regularly checking svc.IsRunning(), or by waiting for
// the svc.ShuttingDown channel to be closed.
//
// When the service func returns, the state is reverted to SERVICE_STOPPED.
func (svm *ServiceManager) Go(service func(svc *ServiceContext) error) bool {
svm.mu.Lock()
defer svm.mu.Unlock()
if !svm.state.CompareAndSwap(SERVICE_STOPPED, SERVICE_RUNNING) {
return false
}
svm.wg.Add(1)
svm.err = nil
svm.shutdown = make(chan struct{})
go func() {
svm.err = service(&ServiceContext{ShuttingDown: svm.shutdown})
svm.state.Set(SERVICE_STOPPED)
svm.wg.Done()
}()
return true
}
// Stop tries to change the state from SERVICE_RUNNING to SERVICE_SHUTTING_DOWN.
// If the current state is not SERVICE_RUNNING, it returns false immediately.
// On successul transition, it waits for the service to finish, and returns true.
// You are allowed to Go() again after a Stop().
func (svm *ServiceManager) Stop() bool {
svm.mu.Lock()
defer svm.mu.Unlock()
if !svm.state.CompareAndSwap(SERVICE_RUNNING, SERVICE_SHUTTING_DOWN) {
return false
}
// Signal the service that we've transitioned to SERVICE_SHUTTING_DOWN.
close(svm.shutdown)
svm.shutdown = nil
svm.wg.Wait()
return true
}
// Wait waits for the service to terminate if it's currently running.
func (svm *ServiceManager) Wait() {
svm.wg.Wait()
}
// Join waits for the service to terminate and returns the value returned by the
// service function.
func (svm *ServiceManager) Join() error {
svm.wg.Wait()
return svm.err
}
// State returns the current state of the service.
// This should only be used to report the current state.
func (svm *ServiceManager) State() int64 {
return svm.state.Get()
}
// StateName returns the name of the current state.
func (svm *ServiceManager) StateName() string {
return stateNames[svm.State()]
}
// ServiceContext is passed into the service function to give it access to
// information about the running service.
type ServiceContext struct {
// ShuttingDown is a channel that the service can select on to be notified
// when it should shut down. The channel is closed when the state transitions
// from SERVICE_RUNNING to SERVICE_SHUTTING_DOWN.
ShuttingDown chan struct{}
}
// IsRunning returns true if the ServiceContext.ShuttingDown channel has not
// been closed yet.
func (svc *ServiceContext) IsRunning() bool {
select {
case <-svc.ShuttingDown:
return false
default:
return true
}
}

202
vendor/github.com/ngaut/tso/LICENSE generated vendored
View file

@ -1,202 +0,0 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "{}"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright {yyyy} {name of copyright owner}
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

243
vendor/github.com/ngaut/tso/client/client.go generated vendored
View file

@ -1,243 +0,0 @@
package client
import (
"container/list"
"time"
"github.com/juju/errors"
"github.com/ngaut/log"
"github.com/ngaut/tso/proto"
"github.com/ngaut/tso/util"
"github.com/ngaut/zkhelper"
)
const (
maxPipelineRequest = 100000
)
// Client is a timestamp oracle client.
type Client struct {
requests chan *PipelineRequest
pending *list.List
conf *Conf
addr string
leaderCh chan string
}
// Conf is the configuration.
type Conf struct {
// tso server address, it will be deprecated later.
ServerAddr string
// ZKAddr is for zookeeper address, if set, client will ignore ServerAddr
// and find the leader tso server address in zookeeper.
// Later ServerAddr is just for simple test and backward compatibility.
ZKAddr string
// root path is the tso server saving in zookeeper, like /zk/tso.
RootPath string
}
// PipelineRequest let you get the timestamp with pipeline.
type PipelineRequest struct {
done chan error
reply *proto.Response
}
func newPipelineRequest() *PipelineRequest {
return &PipelineRequest{
done: make(chan error, 1),
}
}
// MarkDone sets the repsone for current request.
func (pr *PipelineRequest) MarkDone(reply *proto.Response, err error) {
if err != nil {
pr.reply = nil
}
pr.reply = reply
pr.done <- errors.Trace(err)
}
// GetTS gets the timestamp.
func (pr *PipelineRequest) GetTS() (*proto.Timestamp, error) {
err := <-pr.done
if err != nil {
return nil, errors.Trace(err)
}
return &pr.reply.Timestamp, nil
}
// NewClient creates a timestamp oracle client.
func NewClient(conf *Conf) *Client {
c := &Client{
requests: make(chan *PipelineRequest, maxPipelineRequest),
pending: list.New(),
conf: conf,
leaderCh: make(chan string, 1),
}
if len(conf.ZKAddr) == 0 {
c.leaderCh <- conf.ServerAddr
} else {
go c.watchLeader()
}
go c.workerLoop()
return c
}
func (c *Client) cleanupPending(err error) {
log.Warn(err)
length := c.pending.Len()
for i := 0; i < length; i++ {
e := c.pending.Front()
c.pending.Remove(e)
e.Value.(*PipelineRequest).MarkDone(nil, err)
}
// clear request in channel too
length = len(c.requests)
for i := 0; i < length; i++ {
req := <-c.requests
req.MarkDone(nil, err)
}
}
func (c *Client) notifyOne(reply *proto.Response) {
e := c.pending.Front()
c.pending.Remove(e)
req := e.Value.(*PipelineRequest)
req.MarkDone(reply, nil)
}
func (c *Client) writeRequests(session *Conn) error {
var protoHdr [1]byte
for i := 0; i < c.pending.Len(); i++ {
session.Write(protoHdr[:])
}
return session.Flush()
}
func (c *Client) handleResponse(session *Conn) error {
length := c.pending.Len()
for i := 0; i < length; i++ {
var resp proto.Response
err := resp.Decode(session)
if err != nil {
return errors.Trace(err)
}
c.notifyOne(&resp)
}
return nil
}
func (c *Client) do() error {
session, err := NewConnection(c.addr, time.Duration(1*time.Second))
if err != nil {
return errors.Trace(err)
}
log.Debugf("connect tso server %s ok", c.addr)
defer session.Close()
for {
select {
case req := <-c.requests:
c.pending.PushBack(req)
length := len(c.requests)
for i := 0; i < length; i++ {
req = <-c.requests
c.pending.PushBack(req)
}
err = c.writeRequests(session)
if err != nil {
return errors.Trace(err)
}
err = c.handleResponse(session)
if err != nil {
return errors.Trace(err)
}
case addr := <-c.leaderCh:
oldAddr := c.addr
c.addr = addr
return errors.Errorf("leader change %s -> %s", oldAddr, addr)
}
}
}
func (c *Client) workerLoop() {
// first get tso leader
c.addr = <-c.leaderCh
log.Debugf("try to connect tso server %s", c.addr)
for {
err := c.do()
if err != nil {
c.cleanupPending(err)
}
select {
case <-time.After(1 * time.Second):
case addr := <-c.leaderCh:
// If old tso server down, NewConnection will fail and return immediately in do function,
// so we must check leader change here.
log.Warnf("leader change %s -> %s", c.addr, addr)
c.addr = addr
// Wait some time to let tso server allow accepting connections.
time.Sleep(1 * time.Second)
}
}
}
func (c *Client) watchLeader() {
var (
conn zkhelper.Conn
err error
)
for {
conn, err = zkhelper.ConnectToZkWithTimeout(c.conf.ZKAddr, time.Second)
if err != nil {
log.Errorf("connect zk err %v, retry later", err)
time.Sleep(3 * time.Second)
continue
}
break
}
defer conn.Close()
var lastAddr string
for {
addr, watcher, err := util.GetWatchLeader(conn, c.conf.RootPath)
if err != nil {
log.Errorf("get tso leader err %v, retry later", err)
time.Sleep(3 * time.Second)
continue
}
if lastAddr != addr {
log.Warnf("leader change %s -> %s", lastAddr, addr)
lastAddr = addr
c.leaderCh <- addr
}
// watch the leader changes.
<-watcher
}
}
// GoGetTimestamp returns a PipelineRequest so you can get the timestamp later.
func (c *Client) GoGetTimestamp() *PipelineRequest {
pr := newPipelineRequest()
c.requests <- pr
return pr
}

50
vendor/github.com/ngaut/tso/client/conn.go generated vendored
View file

@ -1,50 +0,0 @@
package client
import (
"bufio"
"net"
"time"
"github.com/ngaut/deadline"
)
// Conn is the connection for timestamp oracle server, it is not thread safe.
type Conn struct {
addr string
net.Conn
closed bool
r *bufio.Reader
w *bufio.Writer
netTimeout time.Duration
}
// NewConnection creates a conn.
func NewConnection(addr string, netTimeout time.Duration) (*Conn, error) {
conn, err := net.DialTimeout("tcp", addr, netTimeout)
if err != nil {
return nil, err
}
return &Conn{
addr: addr,
Conn: conn,
r: bufio.NewReaderSize(deadline.NewDeadlineReader(conn, netTimeout), 512*1024),
w: bufio.NewWriterSize(deadline.NewDeadlineWriter(conn, netTimeout), 512*1024),
netTimeout: netTimeout,
}, nil
}
// Read reads data and stores it into p.
func (c *Conn) Read(p []byte) (int, error) {
return c.r.Read(p)
}
// Flush flushs buffered data.
func (c *Conn) Flush() error {
return c.w.Flush()
}
// Write writes p.
func (c *Conn) Write(p []byte) (int, error) {
return c.w.Write(p)
}

45
vendor/github.com/ngaut/tso/proto/proto.go generated vendored
View file

@ -1,45 +0,0 @@
package proto
import (
"encoding/binary"
"io"
"github.com/juju/errors"
)
// RequestHeader is for tso request proto.
type RequestHeader struct {
}
// Timestamp is for tso timestamp.
type Timestamp struct {
Physical int64
Logical int64
}
// Response is for tso reponse proto.
type Response struct {
Timestamp
}
// Encode encodes repsonse proto into w.
func (res *Response) Encode(w io.Writer) error {
var buf [16]byte
binary.BigEndian.PutUint64(buf[0:8], uint64(res.Physical))
binary.BigEndian.PutUint64(buf[8:16], uint64(res.Logical))
_, err := w.Write(buf[0:16])
return errors.Trace(err)
}
// Decode decodes reponse proto from r.
func (res *Response) Decode(r io.Reader) error {
var buf [16]byte
_, err := io.ReadFull(r, buf[0:16])
if err != nil {
return errors.Trace(err)
}
res.Physical = int64(binary.BigEndian.Uint64(buf[0:8]))
res.Logical = int64(binary.BigEndian.Uint64(buf[8:16]))
return nil
}

81
vendor/github.com/ngaut/tso/util/util.go generated vendored
View file

@ -1,81 +0,0 @@
// Copyright 2015 PingCAP, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// See the License for the specific language governing permissions and
// limitations under the License.
package util
import (
"encoding/json"
"path"
"github.com/juju/errors"
"github.com/ngaut/go-zookeeper/zk"
"github.com/ngaut/zkhelper"
)
func getLeader(data []byte) (string, error) {
m := struct {
Addr string `json:"Addr"`
}{}
err := json.Unmarshal(data, &m)
if err != nil {
return "", errors.Trace(err)
}
return m.Addr, nil
}
// getLeaderPath gets the leader path in zookeeper.
func getLeaderPath(rootPath string) string {
return path.Join(rootPath, "leader")
}
// func checkLeaderExists(conn zkhelper.Conn) error {
// // the leader node is not ephemeral, so we may meet no any tso server but leader node
// // has the data for last closed tso server.
// // TODO: check children in /candidates, if no child, we will treat it as no leader too.
// return nil
// }
// GetLeaderAddr gets the leader tso address in zookeeper for outer use.
func GetLeader(conn zkhelper.Conn, rootPath string) (string, error) {
data, _, err := conn.Get(getLeaderPath(rootPath))
if err != nil {
return "", errors.Trace(err)
}
// if err != checkLeaderExists(conn); err != nil {
// return "", errors.Trace(err)
// }
return getLeader(data)
}
// GetWatchLeader gets the leader tso address in zookeeper and returns a watcher for leader change.
func GetWatchLeader(conn zkhelper.Conn, rootPath string) (string, <-chan zk.Event, error) {
data, _, watcher, err := conn.GetW(getLeaderPath(rootPath))
if err != nil {
return "", nil, errors.Trace(err)
}
addr, err := getLeader(data)
if err != nil {
return "", nil, errors.Trace(err)
}
// if err != checkLeaderExists(conn); err != nil {
// return "", errors.Trace(err)
// }
return addr, watcher, nil
}

53
vendor/github.com/ngaut/zkhelper/conn.go generated vendored
View file

@ -1,53 +0,0 @@
package zkhelper
import (
zk "github.com/ngaut/go-zookeeper/zk"
)
/*
type Stat interface {
Czxid() int64
Mzxid() int64
CTime() time.Time
MTime() time.Time
Version() int
CVersion() int
AVersion() int
EphemeralOwner() int64
DataLength() int
NumChildren() int
Pzxid() int64
}
*/
// This interface is really close to the zookeeper connection
// interface. It uses the Stat interface defined here instead of the
// zookeeper.Stat structure for stats. Everything else is the same as
// in zookeeper. So refer to the zookeeper docs for the conventions
// used here (for instance, using -1 as version to specify any
// version)
type Conn interface {
Get(path string) (data []byte, stat zk.Stat, err error)
GetW(path string) (data []byte, stat zk.Stat, watch <-chan zk.Event, err error)
Children(path string) (children []string, stat zk.Stat, err error)
ChildrenW(path string) (children []string, stat zk.Stat, watch <-chan zk.Event, err error)
Exists(path string) (exist bool, stat zk.Stat, err error)
ExistsW(path string) (exist bool, stat zk.Stat, watch <-chan zk.Event, err error)
Create(path string, value []byte, flags int32, aclv []zk.ACL) (pathCreated string, err error)
Set(path string, value []byte, version int32) (stat zk.Stat, err error)
Delete(path string, version int32) (err error)
Close()
//RetryChange(path string, flags int, acl []ACL, changeFunc ChangeFunc) error
GetACL(path string) ([]zk.ACL, zk.Stat, error)
SetACL(path string, aclv []zk.ACL, version int32) (zk.Stat, error)
Seq2Str(seq int64) string
}

472
vendor/github.com/ngaut/zkhelper/etcd.go generated vendored
View file

@ -1,472 +0,0 @@
package zkhelper
import (
"errors"
"fmt"
"path"
"strings"
"sync"
"time"
etcderr "github.com/coreos/etcd/error"
"github.com/coreos/go-etcd/etcd"
zk "github.com/ngaut/go-zookeeper/zk"
"github.com/ngaut/log"
"github.com/ngaut/pools"
)
var (
singleInstanceLock sync.Mutex
etcdInstance *etcdImpl
)
type PooledEtcdClient struct {
c *etcd.Client
}
func (c *PooledEtcdClient) Close() {
}
func (e *etcdImpl) Seq2Str(seq int64) string {
return fmt.Sprintf("%d", seq)
}
type etcdImpl struct {
sync.Mutex
cluster string
pool *pools.ResourcePool
indexMap map[string]uint64
}
func convertToZkError(err error) error {
//todo: convert other errors
if ec, ok := err.(*etcd.EtcdError); ok {
switch ec.ErrorCode {
case etcderr.EcodeKeyNotFound:
return zk.ErrNoNode
case etcderr.EcodeNotFile:
case etcderr.EcodeNotDir:
case etcderr.EcodeNodeExist:
return zk.ErrNodeExists
case etcderr.EcodeDirNotEmpty:
return zk.ErrNotEmpty
}
}
return err
}
func convertToZkEvent(watchPath string, resp *etcd.Response, err error) zk.Event {
//log.Infof("convert event from path:%s, %+v, %+v", watchPath, resp, resp.Node.Key)
var e zk.Event
if err != nil {
e.Err = convertToZkError(err)
e.State = zk.StateDisconnected
return e
}
e.State = zk.StateConnected
e.Path = resp.Node.Key
if len(resp.Node.Key) > len(watchPath) {
e.Type = zk.EventNodeChildrenChanged
return e
}
switch resp.Action {
case "set":
e.Type = zk.EventNodeDataChanged
case "delete":
e.Type = zk.EventNodeDeleted
case "update":
e.Type = zk.EventNodeDataChanged
case "create":
e.Type = zk.EventNodeCreated
case "expire":
e.Type = zk.EventNotWatching
}
return e
}
func NewEtcdConn(zkAddr string) (Conn, error) {
singleInstanceLock.Lock()
defer singleInstanceLock.Unlock()
if etcdInstance != nil {
return etcdInstance, nil
}
p := pools.NewResourcePool(func() (pools.Resource, error) {
cluster := strings.Split(zkAddr, ",")
for i, addr := range cluster {
if !strings.HasPrefix(addr, "http://") {
cluster[i] = "http://" + addr
}
}
newClient := etcd.NewClient(cluster)
newClient.SetConsistency(etcd.STRONG_CONSISTENCY)
return &PooledEtcdClient{c: newClient}, nil
}, 10, 10, 0)
etcdInstance = &etcdImpl{
cluster: zkAddr,
pool: p,
indexMap: make(map[string]uint64),
}
log.Infof("new etcd %s", zkAddr)
if etcdInstance == nil {
return nil, errors.New("unknown error")
}
return etcdInstance, nil
}
func (e *etcdImpl) Get(key string) (data []byte, stat zk.Stat, err error) {
conn, err := e.pool.Get()
if err != nil {
return nil, nil, err
}
defer e.pool.Put(conn)
c := conn.(*PooledEtcdClient).c
resp, err := c.Get(key, true, false)
if resp == nil {
return nil, nil, convertToZkError(err)
}
return []byte(resp.Node.Value), nil, nil
}
func (e *etcdImpl) setIndex(key string, index uint64) {
e.Lock()
defer e.Unlock()
e.indexMap[key] = index
}
func (e *etcdImpl) getIndex(key string) uint64 {
e.Lock()
defer e.Unlock()
index := e.indexMap[key]
return index
}
func (e *etcdImpl) watch(key string, children bool) (resp *etcd.Response, stat zk.Stat, watch <-chan zk.Event, err error) {
conn, err := e.pool.Get()
if err != nil {
return nil, nil, nil, err
}
defer e.pool.Put(conn)
c := conn.(*PooledEtcdClient).c
index := e.getIndex(key)
resp, err = c.Get(key, true, true)
if resp == nil {
return nil, nil, nil, convertToZkError(err)
}
if index < resp.Node.ModifiedIndex {
index = resp.Node.ModifiedIndex
}
for _, n := range resp.Node.Nodes {
if n.ModifiedIndex > index {
index = n.ModifiedIndex
}
}
log.Info("try watch", key)
ch := make(chan zk.Event, 100)
originVal := resp.Node.Value
go func() {
defer func() {
e.setIndex(key, index)
}()
for {
conn, err := e.pool.Get()
if err != nil {
log.Error(err)
return
}
c := conn.(*PooledEtcdClient).c
resp, err := c.Watch(key, index, children, nil, nil)
e.pool.Put(conn)
if err != nil {
if ec, ok := err.(*etcd.EtcdError); ok {
if ec.ErrorCode == etcderr.EcodeEventIndexCleared {
index++
continue
}
}
log.Warning("watch", err)
ch <- convertToZkEvent(key, resp, err)
return
}
if key == resp.Node.Key && originVal == string(resp.Node.Value) { //keep alive event
index++
continue
}
ch <- convertToZkEvent(key, resp, err)
//update index
if index <= resp.Node.ModifiedIndex {
index = resp.Node.ModifiedIndex + 1
} else {
index++
}
return
}
}()
return resp, nil, ch, nil
}
func (e *etcdImpl) GetW(key string) (data []byte, stat zk.Stat, watch <-chan zk.Event, err error) {
resp, stat, watch, err := e.watch(key, false)
if err != nil {
return
}
return []byte(resp.Node.Value), stat, watch, nil
}
func (e *etcdImpl) Children(key string) (children []string, stat zk.Stat, err error) {
conn, err := e.pool.Get()
if err != nil {
return nil, nil, err
}
defer e.pool.Put(conn)
c := conn.(*PooledEtcdClient).c
resp, err := c.Get(key, true, false)
if resp == nil {
return nil, nil, convertToZkError(err)
}
for _, c := range resp.Node.Nodes {
children = append(children, path.Base(c.Key))
}
return
}
func (e *etcdImpl) ChildrenW(key string) (children []string, stat zk.Stat, watch <-chan zk.Event, err error) {
resp, stat, watch, err := e.watch(key, true)
if err != nil {
return nil, stat, nil, convertToZkError(err)
}
for _, c := range resp.Node.Nodes {
children = append(children, path.Base(c.Key))
}
return children, stat, watch, nil
}
func (e *etcdImpl) Exists(key string) (exist bool, stat zk.Stat, err error) {
conn, err := e.pool.Get()
if err != nil {
return false, nil, err
}
defer e.pool.Put(conn)
c := conn.(*PooledEtcdClient).c
_, err = c.Get(key, true, false)
if err == nil {
return true, nil, nil
}
if ec, ok := err.(*etcd.EtcdError); ok {
if ec.ErrorCode == etcderr.EcodeKeyNotFound {
return false, nil, nil
}
}
return false, nil, convertToZkError(err)
}
func (e *etcdImpl) ExistsW(key string) (exist bool, stat zk.Stat, watch <-chan zk.Event, err error) {
_, stat, watch, err = e.watch(key, false)
if err != nil {
return false, nil, nil, convertToZkError(err)
}
return true, nil, watch, nil
}
const MAX_TTL = 365 * 24 * 60 * 60
func (e *etcdImpl) doKeepAlive(key string, ttl uint64) error {
conn, err := e.pool.Get()
if err != nil {
return err
}
defer e.pool.Put(conn)
c := conn.(*PooledEtcdClient).c
resp, err := c.Get(key, false, false)
if err != nil {
log.Error(err)
return err
}
if resp.Node.Dir {
return fmt.Errorf("can not set ttl to directory", key)
}
//log.Info("keep alive ", key)
resp, err = c.CompareAndSwap(key, resp.Node.Value, ttl, resp.Node.Value, resp.Node.ModifiedIndex)
if err == nil {
return nil
}
if ec, ok := err.(*etcd.EtcdError); ok && ec.ErrorCode == etcderr.EcodeTestFailed {
return nil
}
return err
}
//todo:add test for keepAlive
func (e *etcdImpl) keepAlive(key string, ttl uint64) {
go func() {
for {
time.Sleep(1 * time.Second)
err := e.doKeepAlive(key, ttl)
if err != nil {
log.Error(err)
return
}
}
}()
}
func (e *etcdImpl) Create(wholekey string, value []byte, flags int32, aclv []zk.ACL) (keyCreated string, err error) {
seq := (flags & zk.FlagSequence) != 0
tmp := (flags & zk.FlagEphemeral) != 0
ttl := uint64(MAX_TTL)
if tmp {
ttl = 5
}
var resp *etcd.Response
conn, err := e.pool.Get()
if err != nil {
return "", err
}
defer e.pool.Put(conn)
c := conn.(*PooledEtcdClient).c
fn := c.Create
log.Info("create", wholekey)
if seq {
wholekey = path.Dir(wholekey)
fn = c.CreateInOrder
} else {
for _, v := range aclv {
if v.Perms == PERM_DIRECTORY {
log.Info("etcdImpl:create directory", wholekey)
fn = nil
resp, err = c.CreateDir(wholekey, uint64(ttl))
if err != nil {
return "", convertToZkError(err)
}
}
}
}
if fn == nil {
if tmp {
e.keepAlive(wholekey, ttl)
}
return resp.Node.Key, nil
}
resp, err = fn(wholekey, string(value), uint64(ttl))
if err != nil {
return "", convertToZkError(err)
}
if tmp {
e.keepAlive(resp.Node.Key, ttl)
}
return resp.Node.Key, nil
}
func (e *etcdImpl) Set(key string, value []byte, version int32) (stat zk.Stat, err error) {
if version == 0 {
return nil, errors.New("invalid version")
}
conn, err := e.pool.Get()
if err != nil {
return nil, err
}
defer e.pool.Put(conn)
c := conn.(*PooledEtcdClient).c
resp, err := c.Get(key, true, false)
if resp == nil {
return nil, convertToZkError(err)
}
_, err = c.Set(key, string(value), uint64(resp.Node.TTL))
return nil, convertToZkError(err)
}
func (e *etcdImpl) Delete(key string, version int32) (err error) {
//todo: handle version
conn, err := e.pool.Get()
if err != nil {
return err
}
defer e.pool.Put(conn)
c := conn.(*PooledEtcdClient).c
resp, err := c.Get(key, true, false)
if resp == nil {
return convertToZkError(err)
}
if resp.Node.Dir {
_, err = c.DeleteDir(key)
} else {
_, err = c.Delete(key, false)
}
return convertToZkError(err)
}
func (e *etcdImpl) GetACL(key string) ([]zk.ACL, zk.Stat, error) {
return nil, nil, nil
}
func (e *etcdImpl) SetACL(key string, aclv []zk.ACL, version int32) (zk.Stat, error) {
return nil, nil
}
func (e *etcdImpl) Close() {
//how to implement this
}

519
vendor/github.com/ngaut/zkhelper/fakezk.go generated vendored
View file

@ -1,519 +0,0 @@
// Copyright 2013, Google Inc. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Package fakezk is a pretty complete mock implementation of a
// Zookeper connection (see go/zk/zk.Conn). All operations
// work as expected with the exceptions of zk.Conn.ACL and
// zk.Conn.SetACL. zk.Conn.SetACL will succeed, but it is a noop (and
// the ACLs won't be respected). zk.Conn.ACL will panic. It is OK to
// access the connection from multiple goroutines, but the locking is
// very naive (every operation locks the whole connection).
package zkhelper
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"strings"
"sync"
"time"
"github.com/ngaut/go-zookeeper/zk"
)
type zconn struct {
mu sync.Mutex
root *stat
zxid int64
existWatches map[string][]chan zk.Event
}
func (conn *zconn) getZxid() int64 {
conn.zxid++
return conn.zxid
}
func (conn *zconn) Seq2Str(seq int64) string {
return fmt.Sprintf("%0.10d", seq)
}
// NewConn returns a fake zk.Conn implementation. Data is stored in
// memory, and there's a global connection lock for concurrent access.
func NewConn() Conn {
return &zconn{
root: &stat{
name: "/",
children: make(map[string]*stat),
},
existWatches: make(map[string][]chan zk.Event)}
}
// NewConnFromFile returns a fake zk.Conn implementation, that is seeded
// with the json data extracted from the input file.
func NewConnFromFile(filename string) Conn {
result := &zconn{
root: &stat{
name: "/",
children: make(map[string]*stat),
},
existWatches: make(map[string][]chan zk.Event)}
data, err := ioutil.ReadFile(filename)
if err != nil {
panic(fmt.Errorf("NewConnFromFile failed to read file %v: %v", filename, err))
}
values := make(map[string]interface{})
if err := json.Unmarshal(data, &values); err != nil {
panic(fmt.Errorf("NewConnFromFile failed to json.Unmarshal file %v: %v", filename, err))
}
for k, v := range values {
jv, err := json.Marshal(v)
if err != nil {
panic(fmt.Errorf("NewConnFromFile failed to json.Marshal value %v: %v", k, err))
}
// CreateRecursive will work for a leaf node where the parent
// doesn't exist, but not for a node in the middle of a tree
// that already exists. So have to use 'Set' as a backup.
if _, err := CreateRecursive(result, k, string(jv), 0, nil); err != nil {
if ZkErrorEqual(err, zk.ErrNodeExists) {
_, err = result.Set(k, jv, -1)
}
if err != nil {
panic(fmt.Errorf("NewConnFromFile failed to zk.CreateRecursive value %v: %v", k, err))
}
}
}
return result
}
func (conn *zconn) GetACL(path string) ([]zk.ACL, zk.Stat, error) {
return nil, nil, nil
}
func (conn *zconn) Get(zkPath string) (data []byte, stat zk.Stat, err error) {
conn.mu.Lock()
defer conn.mu.Unlock()
node, _, rest, err := conn.getNode(zkPath, "get")
if err != nil {
return nil, nil, err
}
if len(rest) != 0 {
return nil, nil, zkError(zk.ErrNoNode, "get", zkPath)
}
return []byte(node.content), node, nil
}
func (conn *zconn) GetW(zkPath string) (data []byte, stat zk.Stat, watch <-chan zk.Event, err error) {
conn.mu.Lock()
defer conn.mu.Unlock()
node, _, rest, err := conn.getNode(zkPath, "getw")
if err != nil {
return nil, nil, nil, err
}
if len(rest) != 0 {
return nil, nil, nil, zkError(zk.ErrNoNode, "getw", zkPath)
}
c := make(chan zk.Event, 1)
node.changeWatches = append(node.changeWatches, c)
return []byte(node.content), node, c, nil
}
func (conn *zconn) Children(zkPath string) (children []string, stat zk.Stat, err error) {
conn.mu.Lock()
defer conn.mu.Unlock()
//println("Children:", conn.String())
node, _, rest, err := conn.getNode(zkPath, "children")
if err != nil {
return nil, nil, err
}
if len(rest) != 0 {
return nil, nil, zkError(zk.ErrNoNode, "children", zkPath)
}
for name := range node.children {
children = append(children, name)
}
return children, node, nil
}
func (conn *zconn) ChildrenW(zkPath string) (children []string, stat zk.Stat, watch <-chan zk.Event, err error) {
conn.mu.Lock()
defer conn.mu.Unlock()
//println("ChildrenW:", conn.String())
node, _, rest, err := conn.getNode(zkPath, "childrenw")
if err != nil {
return nil, nil, nil, err
}
if len(rest) != 0 {
return nil, nil, nil, zkError(zk.ErrNoNode, "childrenw", zkPath)
}
c := make(chan zk.Event, 1)
node.childrenWatches = append(node.childrenWatches, c)
for name := range node.children {
children = append(children, name)
}
return children, node, c, nil
}
func (conn *zconn) Exists(zkPath string) (exist bool, stat zk.Stat, err error) {
// FIXME(szopa): if the path is bad, Op will be "get."
exist = false
_, stat, err = conn.Get(zkPath)
if err != nil {
if ZkErrorEqual(err, zk.ErrNoNode) {
err = nil
}
} else {
exist = true
}
return exist, stat, err
}
func (conn *zconn) ExistsW(zkPath string) (exist bool, stat zk.Stat, watch <-chan zk.Event, err error) {
conn.mu.Lock()
defer conn.mu.Unlock()
exist = false
c := make(chan zk.Event, 1)
node, _, rest, err := conn.getNode(zkPath, "existsw")
if err != nil {
return exist, nil, nil, err
}
if len(rest) != 0 {
watches, ok := conn.existWatches[zkPath]
if !ok {
watches = make([]chan zk.Event, 0)
conn.existWatches[zkPath] = watches
}
conn.existWatches[zkPath] = append(watches, c)
return exist, nil, c, nil
}
exist = true
node.existWatches = append(node.existWatches, c)
return exist, node, c, nil
}
func (conn *zconn) Create(zkPath string, value []byte, flags int32, aclv []zk.ACL) (zkPathCreated string, err error) {
conn.mu.Lock()
defer conn.mu.Unlock()
node, _, rest, err := conn.getNode(zkPath, "create")
if err != nil {
return "", err
}
if len(rest) == 0 {
return "", zkError(zk.ErrNodeExists, "create", zkPath)
}
if len(rest) > 1 {
return "", zkError(zk.ErrNoNode, "create", zkPath)
}
zxid := conn.getZxid()
name := rest[0]
if (flags & zk.FlagSequence) != 0 {
sequence := node.nextSequence()
name += sequence
zkPath = zkPath + sequence
}
stat := &stat{
name: name,
content: string(value),
children: make(map[string]*stat),
acl: aclv,
mtime: time.Now(),
ctime: time.Now(),
czxid: zxid,
mzxid: zxid,
existWatches: make([]chan zk.Event, 0),
}
node.children[name] = stat
event := zk.Event{
Type: zk.EventNodeCreated,
Path: zkPath,
State: zk.StateConnected,
}
if watches, ok := conn.existWatches[zkPath]; ok {
delete(conn.existWatches, zkPath)
for _, watch := range watches {
watch <- event
}
}
childrenEvent := zk.Event{
Type: zk.EventNodeChildrenChanged,
Path: zkPath,
State: zk.StateConnected,
}
for _, watch := range node.childrenWatches {
watch <- childrenEvent
close(watch)
}
node.childrenWatches = nil
node.cversion++
return zkPath, nil
}
func (conn *zconn) Set(zkPath string, value []byte, version int32) (stat zk.Stat, err error) {
conn.mu.Lock()
defer conn.mu.Unlock()
node, _, rest, err := conn.getNode(zkPath, "set")
if err != nil {
return nil, err
}
if len(rest) != 0 {
return nil, zkError(zk.ErrNoNode, "set", zkPath)
}
if version != -1 && node.version != int(version) {
return nil, zkError(zk.ErrBadVersion, "set", zkPath)
}
node.content = string(value)
node.version++
for _, watch := range node.changeWatches {
watch <- zk.Event{
Type: zk.EventNodeDataChanged,
Path: zkPath,
State: zk.StateConnected,
}
}
node.changeWatches = nil
return node, nil
}
func (conn *zconn) Delete(zkPath string, version int32) (err error) {
conn.mu.Lock()
defer conn.mu.Unlock()
node, parent, rest, err := conn.getNode(zkPath, "delete")
if err != nil {
return err
}
if len(rest) > 0 {
return zkError(zk.ErrNoNode, "delete", zkPath)
}
if len(node.children) > 0 {
return zkError(zk.ErrNotEmpty, "delete", zkPath)
}
delete(parent.children, node.name)
event := zk.Event{
Type: zk.EventNodeDeleted,
Path: zkPath,
State: zk.StateConnected,
}
for _, watch := range node.existWatches {
watch <- event
}
for _, watch := range node.changeWatches {
watch <- event
}
node.existWatches = nil
node.changeWatches = nil
childrenEvent := zk.Event{
Type: zk.EventNodeChildrenChanged,
Path: zkPath,
State: zk.StateConnected}
for _, watch := range parent.childrenWatches {
watch <- childrenEvent
}
return nil
}
func (conn *zconn) Close() {
conn.mu.Lock()
defer conn.mu.Unlock()
for _, watches := range conn.existWatches {
for _, c := range watches {
close(c)
}
}
conn.root.closeAllWatches()
}
/*
func (conn *zconn) RetryChange(path string, flags int, acl []zk.ACL, changeFunc zk.ChangeFunc) error {
for {
oldValue, oldStat, err := conn.Get(path)
if err != nil && !ZkErrorEqual(err, zk.ErrNoNode) {
return err
}
newValue, err := changeFunc(oldValue, oldStat)
if err != nil {
return err
}
if oldStat == nil {
_, err := conn.Create(path, newValue, flags, acl)
if err == nil || !ZkErrorEqual(err, zk.ZNODEEXISTS) {
return err
}
continue
}
if newValue == oldValue {
return nil // Nothing to do.
}
_, err = conn.Set(path, newValue, oldStat.Version())
if err == nil || !ZkErrorEqual(err, zk.ZBADVERSION) && !ZkErrorEqual(err, zk.ErrNoNode) {
return err
}
}
}
*/
func (conn *zconn) SetACL(zkPath string, aclv []zk.ACL, version int32) (zk.Stat, error) {
return nil, nil
}
func (conn *zconn) getNode(zkPath string, op string) (node *stat, parent *stat, rest []string, err error) {
// FIXME(szopa): Make sure the path starts with /.
parts := strings.Split(zkPath, "/")
if parts[0] != "" {
//todo: fix this, error bad arguments
return nil, nil, nil, zkError(zk.ErrUnknown, op, zkPath)
}
elements := parts[1:]
parent = nil
current := conn.root
for i, el := range elements {
candidateParent := current
candidate, ok := current.children[el]
if !ok {
return current, parent, elements[i:], nil
}
current, parent = candidate, candidateParent
}
return current, parent, []string{}, nil
}
type ZkError struct {
Code error
Op string
Path string
}
func (ze *ZkError) Error() string {
return ze.Code.Error()
}
// zkError creates an appropriate error return from
// a ZooKeeper status
func zkError(code error, op, path string) error {
return &ZkError{
Op: op,
Code: code,
Path: path,
}
}
type stat struct {
name string
content string
children map[string]*stat
acl []zk.ACL
mtime time.Time
ctime time.Time
czxid int64
mzxid int64
pzxid int64
version int
cversion int
aversion int
sequence int
existWatches []chan zk.Event
changeWatches []chan zk.Event
childrenWatches []chan zk.Event
}
func (st stat) closeAllWatches() {
for _, c := range st.existWatches {
close(c)
}
for _, c := range st.changeWatches {
close(c)
}
for _, c := range st.childrenWatches {
close(c)
}
for _, child := range st.children {
child.closeAllWatches()
}
}
func (st stat) Czxid() int64 {
return st.czxid
}
func (st stat) Mzxid() int64 {
return st.mzxid
}
func (st stat) CTime() time.Time {
return st.ctime
}
func (st stat) MTime() time.Time {
return st.mtime
}
func (st stat) Version() int {
return st.version
}
func (st stat) CVersion() int {
return st.cversion
}
func (st stat) AVersion() int {
return st.aversion
}
func (st stat) EphemeralOwner() int64 {
return 0
}
func (st stat) DataLength() int {
return len(st.content)
}
func (st stat) NumChildren() int {
return len(st.children)
}
func (st stat) Pzxid() int64 {
return st.pzxid
}
func (st *stat) nextSequence() string {
st.sequence++
return fmt.Sprintf("%010d", st.sequence)
}
func (st stat) fprintRecursive(level int, buf *bytes.Buffer) {
start := strings.Repeat(" ", level)
fmt.Fprintf(buf, "%v-%v:\n", start, st.name)
if st.content != "" {
fmt.Fprintf(buf, "%v content: %q\n\n", start, st.content)
}
if len(st.children) > 0 {
for _, child := range st.children {
child.fprintRecursive(level+1, buf)
}
}
}
func (conn *zconn) String() string {
b := new(bytes.Buffer)
conn.root.fprintRecursive(0, b)
return b.String()
}

899
vendor/github.com/ngaut/zkhelper/zk.go generated vendored
View file

@ -1,899 +0,0 @@
// zk helper functions
// modified from Vitess project
package zkhelper
import (
"encoding/json"
"errors"
"fmt"
"math/rand"
"os"
"path"
"sort"
"strings"
"sync"
"time"
"github.com/ngaut/go-zookeeper/zk"
"github.com/ngaut/log"
)
var (
// This error is returned by functions that wait for a result
// when they are interrupted.
ErrInterrupted = errors.New("zkutil: obtaining lock was interrupted")
// This error is returned by functions that wait for a result
// when the timeout value is reached.
ErrTimeout = errors.New("zkutil: obtaining lock timed out")
)
const (
// PERM_DIRECTORY are default permissions for a node.
PERM_DIRECTORY = zk.PermAdmin | zk.PermCreate | zk.PermDelete | zk.PermRead | zk.PermWrite
// PERM_FILE allows a zk node to emulate file behavior by disallowing child nodes.
PERM_FILE = zk.PermAdmin | zk.PermRead | zk.PermWrite
MagicPrefix = "zk"
)
func init() {
rand.Seed(time.Now().UnixNano())
}
type MyZkConn struct {
*zk.Conn
}
func (conn *MyZkConn) Seq2Str(seq int64) string {
return fmt.Sprintf("%0.10d", seq)
}
func ConnectToZk(zkAddr string) (Conn, error) {
zkConn, _, err := zk.Connect(strings.Split(zkAddr, ","), 3*time.Second)
if err != nil {
return nil, err
}
return &MyZkConn{Conn: zkConn}, nil
}
func ConnectToZkWithTimeout(zkAddr string, recvTime time.Duration) (Conn, error) {
zkConn, _, err := zk.Connect(strings.Split(zkAddr, ","), recvTime)
if err != nil {
return nil, err
}
return &MyZkConn{Conn: zkConn}, nil
}
func DefaultACLs() []zk.ACL {
return zk.WorldACL(zk.PermAll)
}
func DefaultDirACLs() []zk.ACL {
return zk.WorldACL(PERM_DIRECTORY)
}
func DefaultFileACLs() []zk.ACL {
return zk.WorldACL(PERM_FILE)
}
// IsDirectory returns if this node should be treated as a directory.
func IsDirectory(aclv []zk.ACL) bool {
for _, acl := range aclv {
if acl.Perms != PERM_DIRECTORY {
return false
}
}
return true
}
func ZkErrorEqual(a, b error) bool {
if a != nil && b != nil {
return a.Error() == b.Error()
}
return a == b
}
// Create a path and any pieces required, think mkdir -p.
// Intermediate znodes are always created empty.
func CreateRecursive(zconn Conn, zkPath, value string, flags int, aclv []zk.ACL) (pathCreated string, err error) {
parts := strings.Split(zkPath, "/")
if parts[1] != MagicPrefix {
return "", fmt.Errorf("zkutil: non /%v path: %v", MagicPrefix, zkPath)
}
pathCreated, err = zconn.Create(zkPath, []byte(value), int32(flags), aclv)
if ZkErrorEqual(err, zk.ErrNoNode) {
// Make sure that nodes are either "file" or "directory" to mirror file system
// semantics.
dirAclv := make([]zk.ACL, len(aclv))
for i, acl := range aclv {
dirAclv[i] = acl
dirAclv[i].Perms = PERM_DIRECTORY
}
_, err = CreateRecursive(zconn, path.Dir(zkPath), "", flags, dirAclv)
if err != nil && !ZkErrorEqual(err, zk.ErrNodeExists) {
return "", err
}
pathCreated, err = zconn.Create(zkPath, []byte(value), int32(flags), aclv)
}
return
}
func CreateOrUpdate(zconn Conn, zkPath, value string, flags int, aclv []zk.ACL, recursive bool) (pathCreated string, err error) {
if recursive {
pathCreated, err = CreateRecursive(zconn, zkPath, value, 0, aclv)
} else {
pathCreated, err = zconn.Create(zkPath, []byte(value), 0, aclv)
}
if err != nil && ZkErrorEqual(err, zk.ErrNodeExists) {
pathCreated = ""
_, err = zconn.Set(zkPath, []byte(value), -1)
}
return
}
type pathItem struct {
path string
err error
}
func ChildrenRecursive(zconn Conn, zkPath string) ([]string, error) {
var err error
mutex := sync.Mutex{}
wg := sync.WaitGroup{}
pathList := make([]string, 0, 32)
children, _, err := zconn.Children(zkPath)
if err != nil {
return nil, err
}
for _, child := range children {
wg.Add(1)
go func(child string) {
childPath := path.Join(zkPath, child)
rChildren, zkErr := ChildrenRecursive(zconn, childPath)
if zkErr != nil {
// If other processes are deleting nodes, we need to ignore
// the missing nodes.
if !ZkErrorEqual(zkErr, zk.ErrNoNode) {
mutex.Lock()
err = zkErr
mutex.Unlock()
}
} else {
mutex.Lock()
pathList = append(pathList, child)
for _, rChild := range rChildren {
pathList = append(pathList, path.Join(child, rChild))
}
mutex.Unlock()
}
wg.Done()
}(child)
}
wg.Wait()
mutex.Lock()
defer mutex.Unlock()
if err != nil {
return nil, err
}
return pathList, nil
}
func HasWildcard(path string) bool {
for i := 0; i < len(path); i++ {
switch path[i] {
case '\\':
if i+1 >= len(path) {
return true
} else {
i++
}
case '*', '?', '[':
return true
}
}
return false
}
func resolveRecursive(zconn Conn, parts []string, toplevel bool) ([]string, error) {
for i, part := range parts {
if HasWildcard(part) {
var children []string
zkParentPath := strings.Join(parts[:i], "/")
var err error
children, _, err = zconn.Children(zkParentPath)
if err != nil {
// we asked for something like
// /zk/cell/aaa/* and
// /zk/cell/aaa doesn't exist
// -> return empty list, no error
// (note we check both a regular zk
// error and the error the test
// produces)
if ZkErrorEqual(err, zk.ErrNoNode) {
return nil, nil
}
// otherwise we return the error
return nil, err
}
sort.Strings(children)
results := make([][]string, len(children))
wg := &sync.WaitGroup{}
mu := &sync.Mutex{}
var firstError error
for j, child := range children {
matched, err := path.Match(part, child)
if err != nil {
return nil, err
}
if matched {
// we have a match!
wg.Add(1)
newParts := make([]string, len(parts))
copy(newParts, parts)
newParts[i] = child
go func(j int) {
defer wg.Done()
subResult, err := resolveRecursive(zconn, newParts, false)
if err != nil {
mu.Lock()
if firstError != nil {
log.Infof("Multiple error: %v", err)
} else {
firstError = err
}
mu.Unlock()
} else {
results[j] = subResult
}
}(j)
}
}
wg.Wait()
if firstError != nil {
return nil, firstError
}
result := make([]string, 0, 32)
for j := 0; j < len(children); j++ {
subResult := results[j]
if subResult != nil {
result = append(result, subResult...)
}
}
// we found a part that is a wildcard, we
// added the children already, we're done
return result, nil
}
}
// no part contains a wildcard, add the path if it exists, and done
path := strings.Join(parts, "/")
if toplevel {
// for whatever the user typed at the toplevel, we don't
// check it exists or not, we just return it
return []string{path}, nil
}
// this is an expanded path, we need to check if it exists
_, stat, err := zconn.Exists(path)
if err != nil {
return nil, err
}
if stat != nil {
return []string{path}, nil
}
return nil, nil
}
// resolve paths like:
// /zk/nyc/vt/tablets/*/action
// /zk/global/vt/keyspaces/*/shards/*/action
// /zk/*/vt/tablets/*/action
// into real existing paths
//
// If you send paths that don't contain any wildcard and
// don't exist, this function will return an empty array.
func ResolveWildcards(zconn Conn, zkPaths []string) ([]string, error) {
// check all the paths start with /zk/ before doing anything
// time consuming
// relax this in case we are not talking to a metaconn and
// just want to talk to a specified instance.
// for _, zkPath := range zkPaths {
// if _, err := ZkCellFromZkPath(zkPath); err != nil {
// return nil, err
// }
// }
results := make([][]string, len(zkPaths))
wg := &sync.WaitGroup{}
mu := &sync.Mutex{}
var firstError error
for i, zkPath := range zkPaths {
wg.Add(1)
parts := strings.Split(zkPath, "/")
go func(i int) {
defer wg.Done()
subResult, err := resolveRecursive(zconn, parts, true)
if err != nil {
mu.Lock()
if firstError != nil {
log.Infof("Multiple error: %v", err)
} else {
firstError = err
}
mu.Unlock()
} else {
results[i] = subResult
}
}(i)
}
wg.Wait()
if firstError != nil {
return nil, firstError
}
result := make([]string, 0, 32)
for i := 0; i < len(zkPaths); i++ {
subResult := results[i]
if subResult != nil {
result = append(result, subResult...)
}
}
return result, nil
}
func DeleteRecursive(zconn Conn, zkPath string, version int) error {
// version: -1 delete any version of the node at path - only applies to the top node
err := zconn.Delete(zkPath, int32(version))
if err == nil {
return nil
}
if !ZkErrorEqual(err, zk.ErrNotEmpty) {
return err
}
// Remove the ability for other nodes to get created while we are trying to delete.
// Otherwise, you can enter a race condition, or get starved out from deleting.
_, err = zconn.SetACL(zkPath, zk.WorldACL(zk.PermAdmin|zk.PermDelete|zk.PermRead), int32(version))
if err != nil {
return err
}
children, _, err := zconn.Children(zkPath)
if err != nil {
return err
}
for _, child := range children {
err := DeleteRecursive(zconn, path.Join(zkPath, child), -1)
if err != nil && !ZkErrorEqual(err, zk.ErrNoNode) {
return fmt.Errorf("zkutil: recursive delete failed: %v", err)
}
}
err = zconn.Delete(zkPath, int32(version))
if err != nil && !ZkErrorEqual(err, zk.ErrNotEmpty) {
err = fmt.Errorf("zkutil: nodes getting recreated underneath delete (app race condition): %v", zkPath)
}
return err
}
// The lexically lowest node is the lock holder - verify that this
// path holds the lock. Call this queue-lock because the semantics are
// a hybrid. Normal zk locks make assumptions about sequential
// numbering that don't hold when the data in a lock is modified.
// if the provided 'interrupted' chan is closed, we'll just stop waiting
// and return an interruption error
func ObtainQueueLock(zconn Conn, zkPath string, wait time.Duration, interrupted chan struct{}) error {
queueNode := path.Dir(zkPath)
lockNode := path.Base(zkPath)
timer := time.NewTimer(wait)
trylock:
children, _, err := zconn.Children(queueNode)
if err != nil {
return fmt.Errorf("zkutil: trylock failed %v", err)
}
sort.Strings(children)
if len(children) > 0 {
if children[0] == lockNode {
return nil
}
if wait > 0 {
prevLock := ""
for i := 1; i < len(children); i++ {
if children[i] == lockNode {
prevLock = children[i-1]
break
}
}
if prevLock == "" {
return fmt.Errorf("zkutil: no previous queue node found: %v", zkPath)
}
zkPrevLock := path.Join(queueNode, prevLock)
_, stat, watch, err := zconn.ExistsW(zkPrevLock)
if err != nil {
return fmt.Errorf("zkutil: unable to watch queued node %v %v", zkPrevLock, err)
}
if stat == nil {
goto trylock
}
select {
case <-timer.C:
break
case <-interrupted:
return ErrInterrupted
case <-watch:
// The precise event doesn't matter - try to read again regardless.
goto trylock
}
}
return ErrTimeout
}
return fmt.Errorf("zkutil: empty queue node: %v", queueNode)
}
func ZkEventOk(e zk.Event) bool {
return e.State == zk.StateConnected
}
func NodeExists(zconn Conn, zkPath string) (bool, error) {
b, _, err := zconn.Exists(zkPath)
return b, err
}
// Close the release channel when you want to clean up nicely.
func CreatePidNode(zconn Conn, zkPath string, contents string, done chan struct{}) error {
// On the first try, assume the cluster is up and running, that will
// help hunt down any config issues present at startup
if _, err := zconn.Create(zkPath, []byte(contents), zk.FlagEphemeral, zk.WorldACL(PERM_FILE)); err != nil {
if ZkErrorEqual(err, zk.ErrNodeExists) {
err = zconn.Delete(zkPath, -1)
}
if err != nil {
return fmt.Errorf("zkutil: failed deleting pid node: %v: %v", zkPath, err)
}
_, err = zconn.Create(zkPath, []byte(contents), zk.FlagEphemeral, zk.WorldACL(PERM_FILE))
if err != nil {
return fmt.Errorf("zkutil: failed creating pid node: %v: %v", zkPath, err)
}
}
go func() {
for {
_, _, watch, err := zconn.GetW(zkPath)
if err != nil {
if ZkErrorEqual(err, zk.ErrNoNode) {
_, err = zconn.Create(zkPath, []byte(contents), zk.FlagEphemeral, zk.WorldACL(zk.PermAll))
if err != nil {
log.Warningf("failed recreating pid node: %v: %v", zkPath, err)
} else {
log.Infof("recreated pid node: %v", zkPath)
continue
}
} else {
log.Warningf("failed reading pid node: %v", err)
}
} else {
select {
case event := <-watch:
if ZkEventOk(event) && event.Type == zk.EventNodeDeleted {
// Most likely another process has started up. However,
// there is a chance that an ephemeral node is deleted by
// the session expiring, yet that same session gets a watch
// notification. This seems like buggy behavior, but rather
// than race too hard on the node, just wait a bit and see
// if the situation resolves itself.
log.Warningf("pid deleted: %v", zkPath)
} else {
log.Infof("pid node event: %v", event)
}
// break here and wait for a bit before attempting
case <-done:
log.Infof("pid watcher stopped on done: %v", zkPath)
return
}
}
select {
// No one likes a thundering herd, least of all zk.
case <-time.After(5*time.Second + time.Duration(rand.Int63n(55e9))):
case <-done:
log.Infof("pid watcher stopped on done: %v", zkPath)
return
}
}
}()
return nil
}
// ZLocker is an interface for a lock that can fail.
type ZLocker interface {
Lock(desc string) error
LockWithTimeout(wait time.Duration, desc string) error
Unlock() error
Interrupt()
}
// Experiment with a little bit of abstraction.
// FIMXE(msolo) This object may need a mutex to ensure it can be shared
// across goroutines.
type zMutex struct {
mu sync.Mutex
zconn Conn
path string // Path under which we try to create lock nodes.
contents string
interrupted chan struct{}
name string // The name of the specific lock node we created.
ephemeral bool
}
// CreateMutex initializes an unaquired mutex. A mutex is released only
// by Unlock. You can clean up a mutex with delete, but you should be
// careful doing so.
func CreateMutex(zconn Conn, zkPath string) ZLocker {
zm, err := CreateMutexWithContents(zconn, zkPath, map[string]interface{}{})
if err != nil {
panic(err) // should never happen
}
return zm
}
// CreateMutex initializes an unaquired mutex with special content for this mutex.
// A mutex is released only by Unlock. You can clean up a mutex with delete, but you should be
// careful doing so.
func CreateMutexWithContents(zconn Conn, zkPath string, contents map[string]interface{}) (ZLocker, error) {
hostname, err := os.Hostname()
if err != nil {
return nil, err
}
pid := os.Getpid()
contents["hostname"] = hostname
contents["pid"] = pid
data, err := json.Marshal(contents)
if err != nil {
return nil, err
}
return &zMutex{zconn: zconn, path: zkPath, contents: string(data), interrupted: make(chan struct{})}, nil
}
// Interrupt releases a lock that's held.
func (zm *zMutex) Interrupt() {
select {
case zm.interrupted <- struct{}{}:
default:
log.Warningf("zmutex interrupt blocked")
}
}
// Lock returns nil when the lock is acquired.
func (zm *zMutex) Lock(desc string) error {
return zm.LockWithTimeout(365*24*time.Hour, desc)
}
// LockWithTimeout returns nil when the lock is acquired. A lock is
// held if the file exists and you are the creator. Setting the wait
// to zero makes this a nonblocking lock check.
//
// FIXME(msolo) Disallow non-super users from removing the lock?
func (zm *zMutex) LockWithTimeout(wait time.Duration, desc string) (err error) {
timer := time.NewTimer(wait)
defer func() {
if panicErr := recover(); panicErr != nil || err != nil {
zm.deleteLock()
}
}()
// Ensure the rendezvous node is here.
// FIXME(msolo) Assuming locks are contended, it will be cheaper to assume this just
// exists.
_, err = CreateRecursive(zm.zconn, zm.path, "", 0, zk.WorldACL(PERM_DIRECTORY))
if err != nil && !ZkErrorEqual(err, zk.ErrNodeExists) {
return err
}
lockPrefix := path.Join(zm.path, "lock-")
zflags := zk.FlagSequence
if zm.ephemeral {
zflags = zflags | zk.FlagEphemeral
}
// update node content
var lockContent map[string]interface{}
err = json.Unmarshal([]byte(zm.contents), &lockContent)
if err != nil {
return err
}
lockContent["desc"] = desc
newContent, err := json.Marshal(lockContent)
if err != nil {
return err
}
createlock:
lockCreated, err := zm.zconn.Create(lockPrefix, newContent, int32(zflags), zk.WorldACL(PERM_FILE))
if err != nil {
return err
}
name := path.Base(lockCreated)
zm.mu.Lock()
zm.name = name
zm.mu.Unlock()
trylock:
children, _, err := zm.zconn.Children(zm.path)
if err != nil {
return fmt.Errorf("zkutil: trylock failed %v", err)
}
sort.Strings(children)
if len(children) == 0 {
return fmt.Errorf("zkutil: empty lock: %v", zm.path)
}
if children[0] == name {
// We are the lock owner.
return nil
}
// This is the degenerate case of a nonblocking lock check. It's not optimal, but
// also probably not worth optimizing.
if wait == 0 {
return ErrTimeout
}
prevLock := ""
for i := 1; i < len(children); i++ {
if children[i] == name {
prevLock = children[i-1]
break
}
}
if prevLock == "" {
// This is an interesting case. The node disappeared
// underneath us, probably due to a session loss. We can
// recreate the lock node (with a new sequence number) and
// keep trying.
log.Warningf("zkutil: no lock node found: %v/%v", zm.path, zm.name)
goto createlock
}
zkPrevLock := path.Join(zm.path, prevLock)
exist, stat, watch, err := zm.zconn.ExistsW(zkPrevLock)
if err != nil {
// FIXME(msolo) Should this be a retry?
return fmt.Errorf("zkutil: unable to watch previous lock node %v %v", zkPrevLock, err)
}
if stat == nil || !exist {
goto trylock
}
select {
case <-timer.C:
return ErrTimeout
case <-zm.interrupted:
return ErrInterrupted
case event := <-watch:
log.Infof("zkutil: lock event: %v", event)
// The precise event doesn't matter - try to read again regardless.
goto trylock
}
panic("unexpected")
}
// Unlock returns nil if the lock was successfully
// released. Otherwise, it is most likely a zk related error.
func (zm *zMutex) Unlock() error {
return zm.deleteLock()
}
func (zm *zMutex) deleteLock() error {
zm.mu.Lock()
zpath := path.Join(zm.path, zm.name)
zm.mu.Unlock()
err := zm.zconn.Delete(zpath, -1)
if err != nil && !ZkErrorEqual(err, zk.ErrNoNode) {
return err
}
return nil
}
// ZElector stores basic state for running an election.
type ZElector struct {
*zMutex
path string
leader string
}
func (ze *ZElector) isLeader() bool {
return ze.leader == ze.name
}
type electionEvent struct {
Event int
Err error
}
type backoffDelay struct {
min time.Duration
max time.Duration
delay time.Duration
}
func newBackoffDelay(min, max time.Duration) *backoffDelay {
return &backoffDelay{min, max, min}
}
func (bd *backoffDelay) NextDelay() time.Duration {
delay := bd.delay
bd.delay = 2 * bd.delay
if bd.delay > bd.max {
bd.delay = bd.max
}
return delay
}
func (bd *backoffDelay) Reset() {
bd.delay = bd.min
}
// ElectorTask is the interface for a task that runs essentially
// forever or until something bad happens. If a task must be stopped,
// it should be handled promptly - no second notification will be
// sent.
type ElectorTask interface {
Run() error
Stop()
// Return true if interrupted, false if it died of natural causes.
// An interrupted task indicates that the election should stop.
Interrupted() bool
}
// CreateElection returns an initialized elector. An election is
// really a cycle of events. You are flip-flopping between leader and
// candidate. It's better to think of this as a stream of events that
// one needs to react to.
func CreateElection(zconn Conn, zkPath string) ZElector {
zm, err := CreateElectionWithContents(zconn, zkPath, map[string]interface{}{})
if err != nil {
// should never happend
panic(err)
}
return zm
}
// CreateElection returns an initialized elector with special contents. An election is
// really a cycle of events. You are flip-flopping between leader and
// candidate. It's better to think of this as a stream of events that
// one needs to react to.
func CreateElectionWithContents(zconn Conn, zkPath string, contents map[string]interface{}) (ZElector, error) {
l, err := CreateMutexWithContents(zconn, path.Join(zkPath, "candidates"), contents)
if err != nil {
return ZElector{}, err
}
zm := l.(*zMutex)
zm.ephemeral = true
return ZElector{zMutex: zm, path: zkPath}, nil
}
// RunTask returns nil when the underlyingtask ends or the error it
// generated.
func (ze *ZElector) RunTask(task ElectorTask) error {
delay := newBackoffDelay(100*time.Millisecond, 1*time.Minute)
leaderPath := path.Join(ze.path, "leader")
for {
_, err := CreateRecursive(ze.zconn, leaderPath, "", 0, zk.WorldACL(PERM_FILE))
if err == nil || ZkErrorEqual(err, zk.ErrNodeExists) {
break
}
log.Warningf("election leader create failed: %v", err)
time.Sleep(delay.NextDelay())
}
for {
err := ze.Lock("RunTask")
if err != nil {
log.Warningf("election lock failed: %v", err)
if err == ErrInterrupted {
return ErrInterrupted
}
continue
}
// Confirm your win and deliver acceptance speech. This notifies
// listeners who will have been watching the leader node for
// changes.
_, err = ze.zconn.Set(leaderPath, []byte(ze.contents), -1)
if err != nil {
log.Warningf("election promotion failed: %v", err)
continue
}
log.Infof("election promote leader %v", leaderPath)
taskErrChan := make(chan error)
go func() {
taskErrChan <- task.Run()
}()
watchLeader:
// Watch the leader so we can get notified if something goes wrong.
data, _, watch, err := ze.zconn.GetW(leaderPath)
if err != nil {
log.Warningf("election unable to watch leader node %v %v", leaderPath, err)
// FIXME(msolo) Add delay
goto watchLeader
}
if string(data) != ze.contents {
log.Warningf("election unable to promote leader")
task.Stop()
// We won the election, but we didn't become the leader. How is that possible?
// (see Bush v. Gore for some inspiration)
// It means:
// 1. Someone isn't playing by the election rules (a bad actor).
// Hard to detect - let's assume we don't have this problem. :)
// 2. We lost our connection somehow and the ephemeral lock was cleared,
// allowing someone else to win the election.
continue
}
// This is where we start our target process and watch for its failure.
waitForEvent:
select {
case <-ze.interrupted:
log.Warning("election interrupted - stop child process")
task.Stop()
// Once the process dies from the signal, this will all tear down.
goto waitForEvent
case taskErr := <-taskErrChan:
// If our code fails, unlock to trigger an election.
log.Infof("election child process ended: %v", taskErr)
ze.Unlock()
if task.Interrupted() {
log.Warningf("election child process interrupted - stepping down")
return ErrInterrupted
}
continue
case zevent := <-watch:
// We had a zk connection hiccup. We have a few choices,
// but it depends on the constraints and the events.
//
// If we get SESSION_EXPIRED our connection loss triggered an
// election that we won't have won and the thus the lock was
// automatically freed. We have no choice but to start over.
if zevent.State == zk.StateExpired {
log.Warningf("election leader watch expired")
task.Stop()
continue
}
// Otherwise, we had an intermittent issue or something touched
// the node. Either we lost our position or someone broke
// protocol and touched the leader node. We just reconnect and
// revalidate. In the meantime, assume we are still the leader
// until we determine otherwise.
//
// On a reconnect we will be able to see the leader
// information. If we still hold the position, great. If not, we
// kill the associated process.
//
// On a leader node change, we need to perform the same
// validation. It's possible an election completes without the
// old leader realizing he is out of touch.
log.Warningf("election leader watch event %v", zevent)
goto watchLeader
}
}
panic("unreachable")
}

4
vendor/github.com/petar/GoLLRB/AUTHORS generated vendored
View file

@ -1,4 +0,0 @@
Petar Maymounkov <petar@5ttt.org>
Vadim Vygonets <vadik@vygo.net>
Ian Smith <iansmith@acm.org>
Martin Bruse

27
vendor/github.com/petar/GoLLRB/LICENSE generated vendored
View file

@ -1,27 +0,0 @@
Copyright (c) 2010, Petar Maymounkov
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
(*) Redistributions of source code must retain the above copyright notice, this list
of conditions and the following disclaimer.
(*) Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution.
(*) Neither the name of Petar Maymounkov nor the names of its contributors may be
used to endorse or promote products derived from this software without specific
prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

39
vendor/github.com/petar/GoLLRB/llrb/avgvar.go generated vendored
View file

@ -1,39 +0,0 @@
// Copyright 2010 Petar Maymounkov. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package llrb
import "math"
// avgVar maintains the average and variance of a stream of numbers
// in a space-efficient manner.
type avgVar struct {
count int64
sum, sumsq float64
}
func (av *avgVar) Init() {
av.count = 0
av.sum = 0.0
av.sumsq = 0.0
}
func (av *avgVar) Add(sample float64) {
av.count++
av.sum += sample
av.sumsq += sample * sample
}
func (av *avgVar) GetCount() int64 { return av.count }
func (av *avgVar) GetAvg() float64 { return av.sum / float64(av.count) }
func (av *avgVar) GetTotal() float64 { return av.sum }
func (av *avgVar) GetVar() float64 {
a := av.GetAvg()
return av.sumsq/float64(av.count) - a*a
}
func (av *avgVar) GetStdDev() float64 { return math.Sqrt(av.GetVar()) }

93
vendor/github.com/petar/GoLLRB/llrb/iterator.go generated vendored
View file

@ -1,93 +0,0 @@
package llrb
type ItemIterator func(i Item) bool
//func (t *Tree) Ascend(iterator ItemIterator) {
// t.AscendGreaterOrEqual(Inf(-1), iterator)
//}
func (t *LLRB) AscendRange(greaterOrEqual, lessThan Item, iterator ItemIterator) {
t.ascendRange(t.root, greaterOrEqual, lessThan, iterator)
}
func (t *LLRB) ascendRange(h *Node, inf, sup Item, iterator ItemIterator) bool {
if h == nil {
return true
}
if !less(h.Item, sup) {
return t.ascendRange(h.Left, inf, sup, iterator)
}
if less(h.Item, inf) {
return t.ascendRange(h.Right, inf, sup, iterator)
}
if !t.ascendRange(h.Left, inf, sup, iterator) {
return false
}
if !iterator(h.Item) {
return false
}
return t.ascendRange(h.Right, inf, sup, iterator)
}
// AscendGreaterOrEqual will call iterator once for each element greater or equal to
// pivot in ascending order. It will stop whenever the iterator returns false.
func (t *LLRB) AscendGreaterOrEqual(pivot Item, iterator ItemIterator) {
t.ascendGreaterOrEqual(t.root, pivot, iterator)
}
func (t *LLRB) ascendGreaterOrEqual(h *Node, pivot Item, iterator ItemIterator) bool {
if h == nil {
return true
}
if !less(h.Item, pivot) {
if !t.ascendGreaterOrEqual(h.Left, pivot, iterator) {
return false
}
if !iterator(h.Item) {
return false
}
}
return t.ascendGreaterOrEqual(h.Right, pivot, iterator)
}
func (t *LLRB) AscendLessThan(pivot Item, iterator ItemIterator) {
t.ascendLessThan(t.root, pivot, iterator)
}
func (t *LLRB) ascendLessThan(h *Node, pivot Item, iterator ItemIterator) bool {
if h == nil {
return true
}
if !t.ascendLessThan(h.Left, pivot, iterator) {
return false
}
if !iterator(h.Item) {
return false
}
if less(h.Item, pivot) {
return t.ascendLessThan(h.Left, pivot, iterator)
}
return true
}
// DescendLessOrEqual will call iterator once for each element less than the
// pivot in descending order. It will stop whenever the iterator returns false.
func (t *LLRB) DescendLessOrEqual(pivot Item, iterator ItemIterator) {
t.descendLessOrEqual(t.root, pivot, iterator)
}
func (t *LLRB) descendLessOrEqual(h *Node, pivot Item, iterator ItemIterator) bool {
if h == nil {
return true
}
if less(h.Item, pivot) || !less(pivot, h.Item) {
if !t.descendLessOrEqual(h.Right, pivot, iterator) {
return false
}
if !iterator(h.Item) {
return false
}
}
return t.descendLessOrEqual(h.Left, pivot, iterator)
}

46
vendor/github.com/petar/GoLLRB/llrb/llrb-stats.go generated vendored
View file

@ -1,46 +0,0 @@
// Copyright 2010 Petar Maymounkov. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package llrb
// GetHeight() returns an item in the tree with key @key, and it's height in the tree
func (t *LLRB) GetHeight(key Item) (result Item, depth int) {
return t.getHeight(t.root, key)
}
func (t *LLRB) getHeight(h *Node, item Item) (Item, int) {
if h == nil {
return nil, 0
}
if less(item, h.Item) {
result, depth := t.getHeight(h.Left, item)
return result, depth + 1
}
if less(h.Item, item) {
result, depth := t.getHeight(h.Right, item)
return result, depth + 1
}
return h.Item, 0
}
// HeightStats() returns the average and standard deviation of the height
// of elements in the tree
func (t *LLRB) HeightStats() (avg, stddev float64) {
av := &avgVar{}
heightStats(t.root, 0, av)
return av.GetAvg(), av.GetStdDev()
}
func heightStats(h *Node, d int, av *avgVar) {
if h == nil {
return
}
av.Add(float64(d))
if h.Left != nil {
heightStats(h.Left, d+1, av)
}
if h.Right != nil {
heightStats(h.Right, d+1, av)
}
}

456
vendor/github.com/petar/GoLLRB/llrb/llrb.go generated vendored
View file

@ -1,456 +0,0 @@
// Copyright 2010 Petar Maymounkov. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// A Left-Leaning Red-Black (LLRB) implementation of 2-3 balanced binary search trees,
// based on the following work:
//
// http://www.cs.princeton.edu/~rs/talks/LLRB/08Penn.pdf
// http://www.cs.princeton.edu/~rs/talks/LLRB/LLRB.pdf
// http://www.cs.princeton.edu/~rs/talks/LLRB/Java/RedBlackBST.java
//
// 2-3 trees (and the run-time equivalent 2-3-4 trees) are the de facto standard BST
// algoritms found in implementations of Python, Java, and other libraries. The LLRB
// implementation of 2-3 trees is a recent improvement on the traditional implementation,
// observed and documented by Robert Sedgewick.
//
package llrb
// Tree is a Left-Leaning Red-Black (LLRB) implementation of 2-3 trees
type LLRB struct {
count int
root *Node
}
type Node struct {
Item
Left, Right *Node // Pointers to left and right child nodes
Black bool // If set, the color of the link (incoming from the parent) is black
// In the LLRB, new nodes are always red, hence the zero-value for node
}
type Item interface {
Less(than Item) bool
}
//
func less(x, y Item) bool {
if x == pinf {
return false
}
if x == ninf {
return true
}
return x.Less(y)
}
// Inf returns an Item that is "bigger than" any other item, if sign is positive.
// Otherwise it returns an Item that is "smaller than" any other item.
func Inf(sign int) Item {
if sign == 0 {
panic("sign")
}
if sign > 0 {
return pinf
}
return ninf
}
var (
ninf = nInf{}
pinf = pInf{}
)
type nInf struct{}
func (nInf) Less(Item) bool {
return true
}
type pInf struct{}
func (pInf) Less(Item) bool {
return false
}
// New() allocates a new tree
func New() *LLRB {
return &LLRB{}
}
// SetRoot sets the root node of the tree.
// It is intended to be used by functions that deserialize the tree.
func (t *LLRB) SetRoot(r *Node) {
t.root = r
}
// Root returns the root node of the tree.
// It is intended to be used by functions that serialize the tree.
func (t *LLRB) Root() *Node {
return t.root
}
// Len returns the number of nodes in the tree.
func (t *LLRB) Len() int { return t.count }
// Has returns true if the tree contains an element whose order is the same as that of key.
func (t *LLRB) Has(key Item) bool {
return t.Get(key) != nil
}
// Get retrieves an element from the tree whose order is the same as that of key.
func (t *LLRB) Get(key Item) Item {
h := t.root
for h != nil {
switch {
case less(key, h.Item):
h = h.Left
case less(h.Item, key):
h = h.Right
default:
return h.Item
}
}
return nil
}
// Min returns the minimum element in the tree.
func (t *LLRB) Min() Item {
h := t.root
if h == nil {
return nil
}
for h.Left != nil {
h = h.Left
}
return h.Item
}
// Max returns the maximum element in the tree.
func (t *LLRB) Max() Item {
h := t.root
if h == nil {
return nil
}
for h.Right != nil {
h = h.Right
}
return h.Item
}
func (t *LLRB) ReplaceOrInsertBulk(items ...Item) {
for _, i := range items {
t.ReplaceOrInsert(i)
}
}
func (t *LLRB) InsertNoReplaceBulk(items ...Item) {
for _, i := range items {
t.InsertNoReplace(i)
}
}
// ReplaceOrInsert inserts item into the tree. If an existing
// element has the same order, it is removed from the tree and returned.
func (t *LLRB) ReplaceOrInsert(item Item) Item {
if item == nil {
panic("inserting nil item")
}
var replaced Item
t.root, replaced = t.replaceOrInsert(t.root, item)
t.root.Black = true
if replaced == nil {
t.count++
}
return replaced
}
func (t *LLRB) replaceOrInsert(h *Node, item Item) (*Node, Item) {
if h == nil {
return newNode(item), nil
}
h = walkDownRot23(h)
var replaced Item
if less(item, h.Item) { // BUG
h.Left, replaced = t.replaceOrInsert(h.Left, item)
} else if less(h.Item, item) {
h.Right, replaced = t.replaceOrInsert(h.Right, item)
} else {
replaced, h.Item = h.Item, item
}
h = walkUpRot23(h)
return h, replaced
}
// InsertNoReplace inserts item into the tree. If an existing
// element has the same order, both elements remain in the tree.
func (t *LLRB) InsertNoReplace(item Item) {
if item == nil {
panic("inserting nil item")
}
t.root = t.insertNoReplace(t.root, item)
t.root.Black = true
t.count++
}
func (t *LLRB) insertNoReplace(h *Node, item Item) *Node {
if h == nil {
return newNode(item)
}
h = walkDownRot23(h)
if less(item, h.Item) {
h.Left = t.insertNoReplace(h.Left, item)
} else {
h.Right = t.insertNoReplace(h.Right, item)
}
return walkUpRot23(h)
}
// Rotation driver routines for 2-3 algorithm
func walkDownRot23(h *Node) *Node { return h }
func walkUpRot23(h *Node) *Node {
if isRed(h.Right) && !isRed(h.Left) {
h = rotateLeft(h)
}
if isRed(h.Left) && isRed(h.Left.Left) {
h = rotateRight(h)
}
if isRed(h.Left) && isRed(h.Right) {
flip(h)
}
return h
}
// Rotation driver routines for 2-3-4 algorithm
func walkDownRot234(h *Node) *Node {
if isRed(h.Left) && isRed(h.Right) {
flip(h)
}
return h
}
func walkUpRot234(h *Node) *Node {
if isRed(h.Right) && !isRed(h.Left) {
h = rotateLeft(h)
}
if isRed(h.Left) && isRed(h.Left.Left) {
h = rotateRight(h)
}
return h
}
// DeleteMin deletes the minimum element in the tree and returns the
// deleted item or nil otherwise.
func (t *LLRB) DeleteMin() Item {
var deleted Item
t.root, deleted = deleteMin(t.root)
if t.root != nil {
t.root.Black = true
}
if deleted != nil {
t.count--
}
return deleted
}
// deleteMin code for LLRB 2-3 trees
func deleteMin(h *Node) (*Node, Item) {
if h == nil {
return nil, nil
}
if h.Left == nil {
return nil, h.Item
}
if !isRed(h.Left) && !isRed(h.Left.Left) {
h = moveRedLeft(h)
}
var deleted Item
h.Left, deleted = deleteMin(h.Left)
return fixUp(h), deleted
}
// DeleteMax deletes the maximum element in the tree and returns
// the deleted item or nil otherwise
func (t *LLRB) DeleteMax() Item {
var deleted Item
t.root, deleted = deleteMax(t.root)
if t.root != nil {
t.root.Black = true
}
if deleted != nil {
t.count--
}
return deleted
}
func deleteMax(h *Node) (*Node, Item) {
if h == nil {
return nil, nil
}
if isRed(h.Left) {
h = rotateRight(h)
}
if h.Right == nil {
return nil, h.Item
}
if !isRed(h.Right) && !isRed(h.Right.Left) {
h = moveRedRight(h)
}
var deleted Item
h.Right, deleted = deleteMax(h.Right)
return fixUp(h), deleted
}
// Delete deletes an item from the tree whose key equals key.
// The deleted item is return, otherwise nil is returned.
func (t *LLRB) Delete(key Item) Item {
var deleted Item
t.root, deleted = t.delete(t.root, key)
if t.root != nil {
t.root.Black = true
}
if deleted != nil {
t.count--
}
return deleted
}
func (t *LLRB) delete(h *Node, item Item) (*Node, Item) {
var deleted Item
if h == nil {
return nil, nil
}
if less(item, h.Item) {
if h.Left == nil { // item not present. Nothing to delete
return h, nil
}
if !isRed(h.Left) && !isRed(h.Left.Left) {
h = moveRedLeft(h)
}
h.Left, deleted = t.delete(h.Left, item)
} else {
if isRed(h.Left) {
h = rotateRight(h)
}
// If @item equals @h.Item and no right children at @h
if !less(h.Item, item) && h.Right == nil {
return nil, h.Item
}
// PETAR: Added 'h.Right != nil' below
if h.Right != nil && !isRed(h.Right) && !isRed(h.Right.Left) {
h = moveRedRight(h)
}
// If @item equals @h.Item, and (from above) 'h.Right != nil'
if !less(h.Item, item) {
var subDeleted Item
h.Right, subDeleted = deleteMin(h.Right)
if subDeleted == nil {
panic("logic")
}
deleted, h.Item = h.Item, subDeleted
} else { // Else, @item is bigger than @h.Item
h.Right, deleted = t.delete(h.Right, item)
}
}
return fixUp(h), deleted
}
// Internal node manipulation routines
func newNode(item Item) *Node { return &Node{Item: item} }
func isRed(h *Node) bool {
if h == nil {
return false
}
return !h.Black
}
func rotateLeft(h *Node) *Node {
x := h.Right
if x.Black {
panic("rotating a black link")
}
h.Right = x.Left
x.Left = h
x.Black = h.Black
h.Black = false
return x
}
func rotateRight(h *Node) *Node {
x := h.Left
if x.Black {
panic("rotating a black link")
}
h.Left = x.Right
x.Right = h
x.Black = h.Black
h.Black = false
return x
}
// REQUIRE: Left and Right children must be present
func flip(h *Node) {
h.Black = !h.Black
h.Left.Black = !h.Left.Black
h.Right.Black = !h.Right.Black
}
// REQUIRE: Left and Right children must be present
func moveRedLeft(h *Node) *Node {
flip(h)
if isRed(h.Right.Left) {
h.Right = rotateRight(h.Right)
h = rotateLeft(h)
flip(h)
}
return h
}
// REQUIRE: Left and Right children must be present
func moveRedRight(h *Node) *Node {
flip(h)
if isRed(h.Left.Left) {
h = rotateRight(h)
flip(h)
}
return h
}
func fixUp(h *Node) *Node {
if isRed(h.Right) {
h = rotateLeft(h)
}
if isRed(h.Left) && isRed(h.Left.Left) {
h = rotateRight(h)
}
if isRed(h.Left) && isRed(h.Right) {
flip(h)
}
return h
}

17
vendor/github.com/petar/GoLLRB/llrb/util.go generated vendored
View file

@ -1,17 +0,0 @@
// Copyright 2010 Petar Maymounkov. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package llrb
type Int int
func (x Int) Less(than Item) bool {
return x < than.(Int)
}
type String string
func (x String) Less(than Item) bool {
return x < than.(String)
}

50
vendor/github.com/pingcap/go-hbase/LICENSE generated vendored
View file

@ -1,50 +0,0 @@
The MIT License (MIT)
Copyright (c) 2015 dongxu
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Copyright (c) 2014 Bryan Peterson. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following disclaimer
in the documentation and/or other materials provided with the
distribution.
* Neither the name of Google Inc. nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

101
vendor/github.com/pingcap/go-hbase/action.go generated vendored
View file

@ -1,101 +0,0 @@
package hbase
import (
pb "github.com/golang/protobuf/proto"
"github.com/juju/errors"
"github.com/ngaut/log"
"github.com/pingcap/go-hbase/proto"
)
type action interface {
ToProto() pb.Message
}
func (c *client) innerCall(table, row []byte, action action, useCache bool) (*call, error) {
region, err := c.LocateRegion(table, row, useCache)
if err != nil {
return nil, errors.Trace(err)
}
conn, err := c.getClientConn(region.Server)
if err != nil {
return nil, errors.Trace(err)
}
regionSpecifier := &proto.RegionSpecifier{
Type: proto.RegionSpecifier_REGION_NAME.Enum(),
Value: []byte(region.Name),
}
var cl *call
switch a := action.(type) {
case *Get:
cl = newCall(&proto.GetRequest{
Region: regionSpecifier,
Get: a.ToProto().(*proto.Get),
})
case *Put, *Delete:
cl = newCall(&proto.MutateRequest{
Region: regionSpecifier,
Mutation: a.ToProto().(*proto.MutationProto),
})
case *CoprocessorServiceCall:
cl = newCall(&proto.CoprocessorServiceRequest{
Region: regionSpecifier,
Call: a.ToProto().(*proto.CoprocessorServiceCall),
})
default:
return nil, errors.Errorf("Unknown action - %T - %v", action, action)
}
err = conn.call(cl)
if err != nil {
// If failed, remove bad server conn cache.
cachedKey := cachedConnKey(region.Server, ClientService)
delete(c.cachedConns, cachedKey)
return nil, errors.Trace(err)
}
return cl, nil
}
func (c *client) innerDo(table, row []byte, action action, useCache bool) (pb.Message, error) {
// Try to create and send a new resuqest call.
cl, err := c.innerCall(table, row, action, useCache)
if err != nil {
log.Warnf("inner call failed - %v", errors.ErrorStack(err))
return nil, errors.Trace(err)
}
// Wait and receive the result.
return <-cl.responseCh, nil
}
func (c *client) do(table, row []byte, action action, useCache bool) (pb.Message, error) {
var (
result pb.Message
err error
)
LOOP:
for i := 0; i < c.maxRetries; i++ {
result, err = c.innerDo(table, row, action, useCache)
if err == nil {
switch r := result.(type) {
case *exception:
err = errors.New(r.msg)
// If get an execption response, clean old region cache.
c.CleanRegionCache(table)
default:
break LOOP
}
}
useCache = false
log.Warnf("Retrying action for the %d time(s), error - %v", i+1, errors.ErrorStack(err))
retrySleep(i + 1)
}
return result, errors.Trace(err)
}

340
vendor/github.com/pingcap/go-hbase/admin.go generated vendored
View file

@ -1,340 +0,0 @@
package hbase
import (
"sort"
"strconv"
"strings"
"time"
"github.com/juju/errors"
"github.com/ngaut/log"
"github.com/pingcap/go-hbase/proto"
)
const defaultNS = "default"
type TableName struct {
namespace string
name string
}
func newTableNameWithDefaultNS(tblName string) TableName {
return TableName{
namespace: defaultNS,
name: tblName,
}
}
type TableDescriptor struct {
name TableName
attrs map[string][]byte
cfs []*ColumnFamilyDescriptor
}
func NewTableDesciptor(tblName string) *TableDescriptor {
ret := &TableDescriptor{
name: newTableNameWithDefaultNS(tblName),
attrs: map[string][]byte{},
}
ret.AddAddr("IS_META", "false")
return ret
}
func (c *TableDescriptor) AddAddr(attrName string, val string) {
c.attrs[attrName] = []byte(val)
}
func (t *TableDescriptor) AddColumnDesc(cf *ColumnFamilyDescriptor) {
for _, c := range t.cfs {
if c.name == cf.name {
return
}
}
t.cfs = append(t.cfs, cf)
}
type ColumnFamilyDescriptor struct {
name string
attrs map[string][]byte
}
func (c *ColumnFamilyDescriptor) AddAttr(attrName string, val string) {
c.attrs[attrName] = []byte(val)
}
// Themis will use VERSIONS=1 for some hook.
func NewColumnFamilyDescriptor(name string) *ColumnFamilyDescriptor {
return newColumnFamilyDescriptor(name, 1)
}
func newColumnFamilyDescriptor(name string, versionsNum int) *ColumnFamilyDescriptor {
versions := strconv.Itoa(versionsNum)
ret := &ColumnFamilyDescriptor{
name: name,
attrs: make(map[string][]byte),
}
// add default attrs
ret.AddAttr("DATA_BLOCK_ENCODING", "NONE")
ret.AddAttr("BLOOMFILTER", "ROW")
ret.AddAttr("REPLICATION_SCOPE", "0")
ret.AddAttr("COMPRESSION", "NONE")
ret.AddAttr("VERSIONS", versions)
ret.AddAttr("TTL", "2147483647") // 1 << 31
ret.AddAttr("MIN_VERSIONS", "0")
ret.AddAttr("KEEP_DELETED_CELLS", "false")
ret.AddAttr("BLOCKSIZE", "65536")
ret.AddAttr("IN_MEMORY", "false")
ret.AddAttr("BLOCKCACHE", "true")
return ret
}
func getPauseTime(retry int) int64 {
if retry >= len(retryPauseTime) {
retry = len(retryPauseTime) - 1
}
if retry < 0 {
retry = 0
}
return retryPauseTime[retry] * defaultRetryWaitMs
}
func (c *client) CreateTable(t *TableDescriptor, splits [][]byte) error {
req := &proto.CreateTableRequest{}
schema := &proto.TableSchema{}
sort.Sort(BytesSlice(splits))
schema.TableName = &proto.TableName{
Qualifier: []byte(t.name.name),
Namespace: []byte(t.name.namespace),
}
for k, v := range t.attrs {
schema.Attributes = append(schema.Attributes, &proto.BytesBytesPair{
First: []byte(k),
Second: []byte(v),
})
}
for _, c := range t.cfs {
cf := &proto.ColumnFamilySchema{
Name: []byte(c.name),
}
for k, v := range c.attrs {
cf.Attributes = append(cf.Attributes, &proto.BytesBytesPair{
First: []byte(k),
Second: []byte(v),
})
}
schema.ColumnFamilies = append(schema.ColumnFamilies, cf)
}
req.TableSchema = schema
req.SplitKeys = splits
ch, err := c.adminAction(req)
if err != nil {
return errors.Trace(err)
}
resp := <-ch
switch r := resp.(type) {
case *exception:
return errors.New(r.msg)
}
// wait and check
for retry := 0; retry < defaultMaxActionRetries*retryLongerMultiplier; retry++ {
regCnt := 0
numRegs := len(splits) + 1
err = c.metaScan(t.name.name, func(r *RegionInfo) (bool, error) {
if !(r.Offline || r.Split) && len(r.Server) > 0 && r.TableName == t.name.name {
regCnt++
}
return true, nil
})
if err != nil {
return errors.Trace(err)
}
if regCnt == numRegs {
return nil
}
log.Warnf("Retrying create table for the %d time(s)", retry+1)
time.Sleep(time.Duration(getPauseTime(retry)) * time.Millisecond)
}
return errors.New("create table timeout")
}
func (c *client) DisableTable(tblName string) error {
req := &proto.DisableTableRequest{
TableName: &proto.TableName{
Qualifier: []byte(tblName),
Namespace: []byte(defaultNS),
},
}
ch, err := c.adminAction(req)
if err != nil {
return errors.Trace(err)
}
resp := <-ch
switch r := resp.(type) {
case *exception:
return errors.New(r.msg)
}
return nil
}
func (c *client) EnableTable(tblName string) error {
req := &proto.EnableTableRequest{
TableName: &proto.TableName{
Qualifier: []byte(tblName),
Namespace: []byte(defaultNS),
},
}
ch, err := c.adminAction(req)
if err != nil {
return errors.Trace(err)
}
resp := <-ch
switch r := resp.(type) {
case *exception:
return errors.New(r.msg)
}
return nil
}
func (c *client) DropTable(tblName string) error {
req := &proto.DeleteTableRequest{
TableName: &proto.TableName{
Qualifier: []byte(tblName),
Namespace: []byte(defaultNS),
},
}
ch, err := c.adminAction(req)
if err != nil {
return errors.Trace(err)
}
resp := <-ch
switch r := resp.(type) {
case *exception:
return errors.New(r.msg)
}
return nil
}
func (c *client) metaScan(tbl string, fn func(r *RegionInfo) (bool, error)) error {
scan := NewScan(metaTableName, 0, c)
defer scan.Close()
scan.StartRow = []byte(tbl)
scan.StopRow = nextKey([]byte(tbl))
for {
r := scan.Next()
if r == nil || scan.Closed() {
break
}
region, err := c.parseRegion(r)
if err != nil {
return errors.Trace(err)
}
if more, err := fn(region); !more || err != nil {
return errors.Trace(err)
}
}
return nil
}
func (c *client) TableExists(tbl string) (bool, error) {
found := false
err := c.metaScan(tbl, func(region *RegionInfo) (bool, error) {
if region.TableName == tbl {
found = true
return false, nil
}
return true, nil
})
if err != nil {
return false, errors.Trace(err)
}
return found, nil
}
// Split splits region.
// tblOrRegion table name or region(<tbl>,<endKey>,<timestamp>.<md5>).
// splitPoint which is a key, leave "" if want to split each region automatically.
func (c *client) Split(tblOrRegion, splitPoint string) error {
// Extract table name from supposing regionName.
tbls := strings.SplitN(tblOrRegion, ",", 2)
tbl := tbls[0]
found := false
var foundRegion *RegionInfo
err := c.metaScan(tbl, func(region *RegionInfo) (bool, error) {
if region != nil && region.Name == tblOrRegion {
found = true
foundRegion = region
return false, nil
}
return true, nil
})
if err != nil {
return errors.Trace(err)
}
// This is a region name, split it directly.
if found {
return c.split(foundRegion, []byte(splitPoint))
}
// This is a table name.
tbl = tblOrRegion
regions, err := c.GetRegions([]byte(tbl), false)
if err != nil {
return errors.Trace(err)
}
// Split each region.
for _, region := range regions {
err := c.split(region, []byte(splitPoint))
if err != nil {
return errors.Trace(err)
}
}
return nil
}
func (c *client) split(region *RegionInfo, splitPoint []byte) error {
// Not in this region, skip it.
if len(splitPoint) > 0 && !findKey(region, splitPoint) {
return nil
}
c.CleanRegionCache([]byte(region.TableName))
rs := NewRegionSpecifier(region.Name)
req := &proto.SplitRegionRequest{
Region: rs,
}
if len(splitPoint) > 0 {
req.SplitPoint = splitPoint
}
// Empty response.
_, err := c.regionAction(region.Server, req)
if err != nil {
return errors.Trace(err)
}
return nil
}

100
vendor/github.com/pingcap/go-hbase/call.go generated vendored
View file

@ -1,100 +0,0 @@
package hbase
import (
"strings"
pb "github.com/golang/protobuf/proto"
"github.com/pingcap/go-hbase/proto"
)
type call struct {
id uint32
methodName string
request pb.Message
responseBuffer pb.Message
responseCh chan pb.Message
}
type exception struct {
msg string
}
func isNotInRegionError(err error) bool {
return strings.Contains(err.Error(), "org.apache.hadoop.hbase.NotServingRegionException")
}
func isUnknownScannerError(err error) bool {
return strings.Contains(err.Error(), "org.apache.hadoop.hbase.UnknownScannerException")
}
func (m *exception) Reset() { *m = exception{} }
func (m *exception) String() string { return m.msg }
func (m *exception) ProtoMessage() {}
func newCall(request pb.Message) *call {
var responseBuffer pb.Message
var methodName string
switch request.(type) {
case *proto.GetRequest:
responseBuffer = &proto.GetResponse{}
methodName = "Get"
case *proto.MutateRequest:
responseBuffer = &proto.MutateResponse{}
methodName = "Mutate"
case *proto.ScanRequest:
responseBuffer = &proto.ScanResponse{}
methodName = "Scan"
case *proto.GetTableDescriptorsRequest:
responseBuffer = &proto.GetTableDescriptorsResponse{}
methodName = "GetTableDescriptors"
case *proto.CoprocessorServiceRequest:
responseBuffer = &proto.CoprocessorServiceResponse{}
methodName = "ExecService"
case *proto.CreateTableRequest:
responseBuffer = &proto.CreateTableResponse{}
methodName = "CreateTable"
case *proto.DisableTableRequest:
responseBuffer = &proto.DisableTableResponse{}
methodName = "DisableTable"
case *proto.EnableTableRequest:
responseBuffer = &proto.EnableTableResponse{}
methodName = "EnableTable"
case *proto.DeleteTableRequest:
responseBuffer = &proto.DeleteTableResponse{}
methodName = "DeleteTable"
case *proto.MultiRequest:
responseBuffer = &proto.MultiResponse{}
methodName = "Multi"
case *proto.SplitRegionRequest:
responseBuffer = &proto.SplitRegionResponse{}
methodName = "SplitRegion"
}
return &call{
methodName: methodName,
request: request,
responseBuffer: responseBuffer,
responseCh: make(chan pb.Message, 1),
}
}
func (c *call) complete(err error, response []byte) {
defer close(c.responseCh)
if err != nil {
c.responseCh <- &exception{
msg: err.Error(),
}
return
}
err = pb.Unmarshal(response, c.responseBuffer)
if err != nil {
c.responseCh <- &exception{
msg: err.Error(),
}
return
}
c.responseCh <- c.responseBuffer
}

454
vendor/github.com/pingcap/go-hbase/client.go generated vendored
View file

@ -1,454 +0,0 @@
package hbase
import (
"bytes"
"crypto/md5"
"encoding/binary"
"encoding/hex"
"fmt"
"sync"
"time"
pb "github.com/golang/protobuf/proto"
"github.com/juju/errors"
"github.com/ngaut/go-zookeeper/zk"
"github.com/ngaut/log"
"github.com/pingcap/go-hbase/proto"
)
const (
zkRootRegionPath = "/meta-region-server"
zkMasterAddrPath = "/master"
magicHeadByte = 0xff
magicHeadSize = 1
idLengthSize = 4
md5HexSize = 32
servernameSeparator = ","
rpcTimeout = 30000
pingTimeout = 30000
callTimeout = 5000
defaultMaxActionRetries = 3
// Some operations can take a long time such as disable of big table.
// numRetries is for 'normal' stuff... Multiply by this factor when
// want to wait a long time.
retryLongerMultiplier = 31
socketDefaultRetryWaitMs = 200
defaultRetryWaitMs = 100
// always >= any unix timestamp(hbase version)
beyondMaxTimestamp = "99999999999999"
)
var (
hbaseHeaderBytes []byte = []byte("HBas")
metaTableName []byte = []byte("hbase:meta")
metaRegionName []byte = []byte("hbase:meta,,1")
)
var retryPauseTime = []int64{1, 2, 3, 5, 10, 20, 40, 100, 100, 100, 100, 200, 200}
type RegionInfo struct {
Server string
StartKey []byte
EndKey []byte
Name string
Ts string
TableNamespace string
TableName string
Offline bool
Split bool
}
type tableInfo struct {
tableName string
families []string
}
// export client interface
type HBaseClient interface {
Get(tbl string, g *Get) (*ResultRow, error)
Put(tbl string, p *Put) (bool, error)
Delete(tbl string, d *Delete) (bool, error)
TableExists(tbl string) (bool, error)
DropTable(t string) error
DisableTable(t string) error
EnableTable(t string) error
CreateTable(t *TableDescriptor, splits [][]byte) error
ServiceCall(table string, call *CoprocessorServiceCall) (*proto.CoprocessorServiceResponse, error)
LocateRegion(table, row []byte, useCache bool) (*RegionInfo, error)
GetRegions(table []byte, useCache bool) ([]*RegionInfo, error)
Split(tblOrRegion, splitPoint string) error
CleanRegionCache(table []byte)
CleanAllRegionCache()
Close() error
}
// hbase client implemetation
var _ HBaseClient = (*client)(nil)
type client struct {
mu sync.RWMutex // for read/update region info
zkClient *zk.Conn
zkHosts []string
zkRoot string
prefetched map[string]bool
cachedConns map[string]*connection
cachedRegionInfo map[string]map[string]*RegionInfo
maxRetries int
rootServerName *proto.ServerName
masterServerName *proto.ServerName
}
func serverNameToAddr(server *proto.ServerName) string {
return fmt.Sprintf("%s:%d", server.GetHostName(), server.GetPort())
}
func cachedConnKey(addr string, srvType ServiceType) string {
return fmt.Sprintf("%s|%d", addr, srvType)
}
func NewClient(zkHosts []string, zkRoot string) (HBaseClient, error) {
cl := &client{
zkHosts: zkHosts,
zkRoot: zkRoot,
cachedConns: make(map[string]*connection),
cachedRegionInfo: make(map[string]map[string]*RegionInfo),
prefetched: make(map[string]bool),
maxRetries: defaultMaxActionRetries,
}
err := cl.init()
if err != nil {
return nil, errors.Trace(err)
}
return cl, nil
}
func (c *client) decodeMeta(data []byte) (*proto.ServerName, error) {
if data[0] != magicHeadByte {
return nil, errors.New("unknown packet")
}
var n int32
err := binary.Read(bytes.NewBuffer(data[1:]), binary.BigEndian, &n)
if err != nil {
return nil, errors.Trace(err)
}
dataOffset := magicHeadSize + idLengthSize + int(n)
data = data[(dataOffset + 4):]
var mrs proto.MetaRegionServer
err = pb.Unmarshal(data, &mrs)
if err != nil {
return nil, errors.Trace(err)
}
return mrs.GetServer(), nil
}
// init and get root region server addr and master addr
func (c *client) init() error {
zkclient, _, err := zk.Connect(c.zkHosts, time.Second*30)
if err != nil {
return errors.Trace(err)
}
c.zkClient = zkclient
res, _, _, err := c.zkClient.GetW(c.zkRoot + zkRootRegionPath)
if err != nil {
return errors.Trace(err)
}
c.rootServerName, err = c.decodeMeta(res)
if err != nil {
return errors.Trace(err)
}
log.Debug("connect root region server...", c.rootServerName)
serverAddr := serverNameToAddr(c.rootServerName)
conn, err := newConnection(serverAddr, ClientService)
if err != nil {
return errors.Trace(err)
}
// Set buffered regionserver conn.
cachedKey := cachedConnKey(serverAddr, ClientService)
c.cachedConns[cachedKey] = conn
res, _, _, err = c.zkClient.GetW(c.zkRoot + zkMasterAddrPath)
if err != nil {
return errors.Trace(err)
}
c.masterServerName, err = c.decodeMeta(res)
if err != nil {
return errors.Trace(err)
}
return nil
}
// get connection
func (c *client) getConn(addr string, srvType ServiceType) (*connection, error) {
connKey := cachedConnKey(addr, srvType)
c.mu.RLock()
conn, ok := c.cachedConns[connKey]
c.mu.RUnlock()
if ok {
return conn, nil
}
var err error
conn, err = newConnection(addr, srvType)
if err != nil {
return nil, errors.Errorf("create new connection failed - %v", errors.ErrorStack(err))
}
c.mu.Lock()
c.cachedConns[connKey] = conn
c.mu.Unlock()
return conn, nil
}
func (c *client) getAdminConn(addr string) (*connection, error) {
return c.getConn(addr, AdminService)
}
func (c *client) getClientConn(addr string) (*connection, error) {
return c.getConn(addr, ClientService)
}
func (c *client) getMasterConn() (*connection, error) {
return c.getConn(serverNameToAddr(c.masterServerName), MasterService)
}
func (c *client) doAction(conn *connection, req pb.Message) (chan pb.Message, error) {
cl := newCall(req)
err := conn.call(cl)
if err != nil {
return nil, errors.Trace(err)
}
return cl.responseCh, nil
}
func (c *client) adminAction(req pb.Message) (chan pb.Message, error) {
conn, err := c.getMasterConn()
if err != nil {
return nil, errors.Trace(err)
}
return c.doAction(conn, req)
}
func (c *client) regionAction(addr string, req pb.Message) (chan pb.Message, error) {
conn, err := c.getAdminConn(addr)
if err != nil {
return nil, errors.Trace(err)
}
return c.doAction(conn, req)
}
// http://stackoverflow.com/questions/27602013/correct-way-to-get-region-name-by-using-hbase-api
func (c *client) createRegionName(table, startKey []byte, id string, newFormat bool) []byte {
if len(startKey) == 0 {
startKey = make([]byte, 1)
}
b := bytes.Join([][]byte{table, startKey, []byte(id)}, []byte{','})
if newFormat {
m := md5.Sum(b)
mhex := []byte(hex.EncodeToString(m[:]))
b = append(bytes.Join([][]byte{b, mhex}, []byte{'.'}), '.')
}
return b
}
func (c *client) parseRegion(rr *ResultRow) (*RegionInfo, error) {
regionInfoCol, ok := rr.Columns["info:regioninfo"]
if !ok {
return nil, errors.Errorf("Unable to parse region location (no regioninfo column): %#v", rr)
}
offset := bytes.Index(regionInfoCol.Value, []byte("PBUF")) + 4
regionInfoBytes := regionInfoCol.Value[offset:]
var info proto.RegionInfo
err := pb.Unmarshal(regionInfoBytes, &info)
if err != nil {
return nil, errors.Errorf("Unable to parse region location: %#v", err)
}
ri := &RegionInfo{
StartKey: info.GetStartKey(),
EndKey: info.GetEndKey(),
Name: bytes.NewBuffer(rr.Row).String(),
TableNamespace: string(info.GetTableName().GetNamespace()),
TableName: string(info.GetTableName().GetQualifier()),
Offline: info.GetOffline(),
Split: info.GetSplit(),
}
if v, ok := rr.Columns["info:server"]; ok {
ri.Server = string(v.Value)
}
return ri, nil
}
func (c *client) getMetaRegion() *RegionInfo {
return &RegionInfo{
StartKey: []byte{},
EndKey: []byte{},
Name: string(metaRegionName),
Server: serverNameToAddr(c.rootServerName),
}
}
func (c *client) getCachedLocation(table, row []byte) *RegionInfo {
c.mu.RLock()
defer c.mu.RUnlock()
tableStr := string(table)
if regions, ok := c.cachedRegionInfo[tableStr]; ok {
for _, region := range regions {
if (len(region.EndKey) == 0 ||
bytes.Compare(row, region.EndKey) < 0) &&
(len(region.StartKey) == 0 ||
bytes.Compare(row, region.StartKey) >= 0) {
return region
}
}
}
return nil
}
func (c *client) updateRegionCache(table []byte, region *RegionInfo) {
c.mu.Lock()
defer c.mu.Unlock()
tableStr := string(table)
if _, ok := c.cachedRegionInfo[tableStr]; !ok {
c.cachedRegionInfo[tableStr] = make(map[string]*RegionInfo)
}
c.cachedRegionInfo[tableStr][region.Name] = region
}
func (c *client) CleanRegionCache(table []byte) {
c.mu.Lock()
defer c.mu.Unlock()
delete(c.cachedRegionInfo, string(table))
}
func (c *client) CleanAllRegionCache() {
c.mu.Lock()
defer c.mu.Unlock()
c.cachedRegionInfo = map[string]map[string]*RegionInfo{}
}
func (c *client) LocateRegion(table, row []byte, useCache bool) (*RegionInfo, error) {
// If user wants to locate metaregion, just return it.
if bytes.Equal(table, metaTableName) {
return c.getMetaRegion(), nil
}
// Try to get location from cache.
if useCache {
if r := c.getCachedLocation(table, row); r != nil {
return r, nil
}
}
// If cache missed or not using cache, try to get and update region info.
metaRegion := c.getMetaRegion()
conn, err := c.getClientConn(metaRegion.Server)
if err != nil {
return nil, errors.Trace(err)
}
regionRow := c.createRegionName(table, row, beyondMaxTimestamp, true)
call := newCall(&proto.GetRequest{
Region: &proto.RegionSpecifier{
Type: proto.RegionSpecifier_REGION_NAME.Enum(),
Value: metaRegionName,
},
Get: &proto.Get{
Row: regionRow,
Column: []*proto.Column{&proto.Column{
Family: []byte("info"),
}},
ClosestRowBefore: pb.Bool(true),
},
})
err = conn.call(call)
if err != nil {
return nil, errors.Trace(err)
}
response := <-call.responseCh
switch r := response.(type) {
case *proto.GetResponse:
res := r.GetResult()
if res == nil {
return nil, errors.Errorf("Empty region: [table=%s] [row=%q] [region_row=%q]", table, row, regionRow)
}
rr := NewResultRow(res)
region, err := c.parseRegion(rr)
if err != nil {
return nil, errors.Trace(err)
}
c.updateRegionCache(table, region)
return region, nil
case *exception:
return nil, errors.New(r.msg)
default:
log.Warnf("Unknown response - %T - %v", r, r)
}
return nil, errors.Errorf("Couldn't find the region: [table=%s] [row=%q] [region_row=%q]", table, row, regionRow)
}
func (c *client) GetRegions(table []byte, useCache bool) ([]*RegionInfo, error) {
var regions []*RegionInfo
startKey := []byte("")
// Get first region.
region, err := c.LocateRegion(table, []byte(startKey), useCache)
if err != nil {
return nil, errors.Errorf("couldn't find any region: [table=%s] [useCache=%t]", table, useCache)
}
regions = append(regions, region)
startKey = region.EndKey
for len(startKey) > 0 {
region, err = c.LocateRegion(table, []byte(startKey), useCache)
if err != nil {
return nil, errors.Trace(err)
}
regions = append(regions, region)
startKey = region.EndKey
}
return regions, nil
}
func (c *client) Close() error {
if c.zkClient != nil {
c.zkClient.Close()
}
for _, conn := range c.cachedConns {
err := conn.close()
if err != nil {
return errors.Trace(err)
}
}
return nil
}

67
vendor/github.com/pingcap/go-hbase/client_ops.go generated vendored
View file

@ -1,67 +0,0 @@
package hbase
import (
"github.com/juju/errors"
"github.com/pingcap/go-hbase/proto"
)
func (c *client) Delete(table string, del *Delete) (bool, error) {
response, err := c.do([]byte(table), del.GetRow(), del, true)
if err != nil {
return false, errors.Trace(err)
}
switch r := response.(type) {
case *proto.MutateResponse:
return r.GetProcessed(), nil
}
return false, errors.Errorf("Invalid response seen [response: %#v]", response)
}
func (c *client) Get(table string, get *Get) (*ResultRow, error) {
response, err := c.do([]byte(table), get.GetRow(), get, true)
if err != nil {
return nil, errors.Trace(err)
}
switch r := response.(type) {
case *proto.GetResponse:
res := r.GetResult()
if res == nil {
return nil, errors.Errorf("Empty response: [table=%s] [row=%q]", table, get.GetRow())
}
return NewResultRow(res), nil
case *exception:
return nil, errors.New(r.msg)
}
return nil, errors.Errorf("Invalid response seen [response: %#v]", response)
}
func (c *client) Put(table string, put *Put) (bool, error) {
response, err := c.do([]byte(table), put.GetRow(), put, true)
if err != nil {
return false, errors.Trace(err)
}
switch r := response.(type) {
case *proto.MutateResponse:
return r.GetProcessed(), nil
}
return false, errors.Errorf("Invalid response seen [response: %#v]", response)
}
func (c *client) ServiceCall(table string, call *CoprocessorServiceCall) (*proto.CoprocessorServiceResponse, error) {
response, err := c.do([]byte(table), call.Row, call, true)
if err != nil {
return nil, errors.Trace(err)
}
switch r := response.(type) {
case *proto.CoprocessorServiceResponse:
return r, nil
case *exception:
return nil, errors.New(r.msg)
}
return nil, errors.Errorf("Invalid response seen [response: %#v]", response)
}

177
vendor/github.com/pingcap/go-hbase/column.go generated vendored
View file

@ -1,177 +0,0 @@
package hbase
import (
"bytes"
"fmt"
"io"
"github.com/juju/errors"
"github.com/pingcap/go-hbase/iohelper"
)
type Column struct {
Family []byte
Qual []byte
}
func NewColumn(family, qual []byte) *Column {
return &Column{
Family: family,
Qual: qual,
}
}
func encode(parts ...[]byte) ([]byte, error) {
buf := &bytes.Buffer{}
for _, p := range parts {
err := iohelper.WriteVarBytes(buf, p)
if err != nil {
return nil, errors.Trace(err)
}
}
return buf.Bytes(), nil
}
func decode(encoded []byte) ([][]byte, error) {
var ret [][]byte
buf := bytes.NewBuffer(encoded)
for {
b, err := iohelper.ReadVarBytes(buf)
if len(b) == 0 || (err != nil && ErrorEqual(err, io.EOF)) {
break
}
ret = append(ret, b)
}
return ret, nil
}
func (c *Column) Write(w io.Writer) error {
err := iohelper.WriteVarBytes(w, c.Family)
if err != nil {
return errors.Trace(err)
}
err = iohelper.WriteVarBytes(w, c.Qual)
if err != nil {
return errors.Trace(err)
}
return nil
}
func (c *Column) String() string {
b, err := encode(c.Family, c.Qual)
if err != nil {
return fmt.Sprintf("invalid column - %v", err)
}
return string(b)
}
func (c *Column) ParseFromString(s string) error {
pairs, err := decode([]byte(s))
if err != nil {
return errors.Trace(err)
}
c.Family = pairs[0]
c.Qual = pairs[1]
return nil
}
type ColumnCoordinate struct {
Table []byte
Row []byte
Column
}
func NewColumnCoordinate(table, row, family, qual []byte) *ColumnCoordinate {
return &ColumnCoordinate{
Table: table,
Row: row,
Column: Column{
Family: family,
Qual: qual,
},
}
}
func (c *ColumnCoordinate) Write(w io.Writer) error {
err := iohelper.WriteVarBytes(w, c.Table)
if err != nil {
return errors.Trace(err)
}
err = iohelper.WriteVarBytes(w, c.Row)
if err != nil {
return errors.Trace(err)
}
err = c.Column.Write(w)
if err != nil {
return errors.Trace(err)
}
return nil
}
func (c *ColumnCoordinate) Equal(a *ColumnCoordinate) bool {
return bytes.Compare(c.Table, a.Table) == 0 &&
bytes.Compare(c.Row, a.Row) == 0 &&
bytes.Compare(c.Family, a.Family) == 0 &&
bytes.Compare(c.Qual, a.Qual) == 0
}
func (c *ColumnCoordinate) String() string {
b, err := encode(c.Table, c.Row, c.Family, c.Qual)
if err != nil {
return fmt.Sprintf("invalid column coordinate - %v", err)
}
return string(b)
}
func (c *ColumnCoordinate) ParseFromString(s string) error {
pairs, err := decode([]byte(s))
if err != nil {
return errors.Trace(err)
}
c.Table = pairs[0]
c.Row = pairs[1]
c.Family = pairs[2]
c.Qual = pairs[3]
return nil
}
func (c *ColumnCoordinate) ParseField(b iohelper.ByteMultiReader) error {
table, err := iohelper.ReadVarBytes(b)
if err != nil {
return errors.Trace(err)
}
c.Table = table
row, err := iohelper.ReadVarBytes(b)
if err != nil {
return errors.Trace(err)
}
c.Row = row
family, err := iohelper.ReadVarBytes(b)
if err != nil {
return errors.Trace(err)
}
c.Family = family
qual, err := iohelper.ReadVarBytes(b)
if err != nil {
return errors.Trace(err)
}
c.Qual = qual
return nil
}
func (c *ColumnCoordinate) GetColumn() *Column {
return &Column{
Family: c.Family,
Qual: c.Qual,
}
}

291
vendor/github.com/pingcap/go-hbase/conn.go generated vendored
View file

@ -1,291 +0,0 @@
package hbase
import (
"bufio"
"bytes"
"io"
"net"
"strings"
"sync"
pb "github.com/golang/protobuf/proto"
"github.com/juju/errors"
"github.com/ngaut/log"
"github.com/pingcap/go-hbase/iohelper"
"github.com/pingcap/go-hbase/proto"
)
type ServiceType byte
const (
MasterMonitorService = iota + 1
MasterService
MasterAdminService
AdminService
ClientService
RegionServerStatusService
)
// convert above const to protobuf string
var ServiceString = map[ServiceType]string{
MasterMonitorService: "MasterMonitorService",
MasterService: "MasterService",
MasterAdminService: "MasterAdminService",
AdminService: "AdminService",
ClientService: "ClientService",
RegionServerStatusService: "RegionServerStatusService",
}
type idGenerator struct {
n int
mu *sync.RWMutex
}
func newIdGenerator() *idGenerator {
return &idGenerator{
n: 0,
mu: &sync.RWMutex{},
}
}
func (a *idGenerator) get() int {
a.mu.RLock()
v := a.n
a.mu.RUnlock()
return v
}
func (a *idGenerator) incrAndGet() int {
a.mu.Lock()
a.n++
v := a.n
a.mu.Unlock()
return v
}
type connection struct {
mu sync.Mutex
addr string
conn net.Conn
bw *bufio.Writer
idGen *idGenerator
serviceType ServiceType
in chan *iohelper.PbBuffer
ongoingCalls map[int]*call
}
func processMessage(msg []byte) ([][]byte, error) {
buf := pb.NewBuffer(msg)
payloads := make([][]byte, 0)
// Question: why can we ignore this error?
for {
hbytes, err := buf.DecodeRawBytes(true)
if err != nil {
// Check whether error is `unexpected EOF`.
if strings.Contains(err.Error(), "unexpected EOF") {
break
}
log.Errorf("Decode raw bytes error - %v", errors.ErrorStack(err))
return nil, errors.Trace(err)
}
payloads = append(payloads, hbytes)
}
return payloads, nil
}
func readPayloads(r io.Reader) ([][]byte, error) {
nBytesExpecting, err := iohelper.ReadInt32(r)
if err != nil {
return nil, errors.Trace(err)
}
if nBytesExpecting > 0 {
buf, err := iohelper.ReadN(r, nBytesExpecting)
// Question: why should we return error only when we get an io.EOF error?
if err != nil && ErrorEqual(err, io.EOF) {
return nil, errors.Trace(err)
}
payloads, err := processMessage(buf)
if err != nil {
return nil, errors.Trace(err)
}
if len(payloads) > 0 {
return payloads, nil
}
}
return nil, errors.New("unexpected payload")
}
func newConnection(addr string, srvType ServiceType) (*connection, error) {
conn, err := net.Dial("tcp", addr)
if err != nil {
return nil, errors.Trace(err)
}
if _, ok := ServiceString[srvType]; !ok {
return nil, errors.Errorf("unexpected service type [serviceType=%d]", srvType)
}
c := &connection{
addr: addr,
bw: bufio.NewWriter(conn),
conn: conn,
in: make(chan *iohelper.PbBuffer, 20),
serviceType: srvType,
idGen: newIdGenerator(),
ongoingCalls: map[int]*call{},
}
err = c.init()
if err != nil {
return nil, errors.Trace(err)
}
return c, nil
}
func (c *connection) init() error {
err := c.writeHead()
if err != nil {
return errors.Trace(err)
}
err = c.writeConnectionHeader()
if err != nil {
return errors.Trace(err)
}
go func() {
err := c.processMessages()
if err != nil {
log.Warnf("process messages failed - %v", errors.ErrorStack(err))
return
}
}()
go c.dispatch()
return nil
}
func (c *connection) processMessages() error {
for {
msgs, err := readPayloads(c.conn)
if err != nil {
return errors.Trace(err)
}
var rh proto.ResponseHeader
err = pb.Unmarshal(msgs[0], &rh)
if err != nil {
return errors.Trace(err)
}
callId := rh.GetCallId()
c.mu.Lock()
call, ok := c.ongoingCalls[int(callId)]
if !ok {
c.mu.Unlock()
return errors.Errorf("Invalid call id: %d", callId)
}
delete(c.ongoingCalls, int(callId))
c.mu.Unlock()
exception := rh.GetException()
if exception != nil {
call.complete(errors.Errorf("Exception returned: %s\n%s", exception.GetExceptionClassName(), exception.GetStackTrace()), nil)
} else if len(msgs) == 2 {
call.complete(nil, msgs[1])
}
}
}
func (c *connection) writeHead() error {
buf := bytes.NewBuffer(nil)
buf.Write(hbaseHeaderBytes)
buf.WriteByte(0)
buf.WriteByte(80)
_, err := c.conn.Write(buf.Bytes())
return errors.Trace(err)
}
func (c *connection) writeConnectionHeader() error {
buf := iohelper.NewPbBuffer()
service := pb.String(ServiceString[c.serviceType])
err := buf.WritePBMessage(&proto.ConnectionHeader{
UserInfo: &proto.UserInformation{
EffectiveUser: pb.String("pingcap"),
},
ServiceName: service,
})
if err != nil {
return errors.Trace(err)
}
err = buf.PrependSize()
if err != nil {
return errors.Trace(err)
}
_, err = c.conn.Write(buf.Bytes())
if err != nil {
return errors.Trace(err)
}
return nil
}
func (c *connection) dispatch() {
for {
select {
case buf := <-c.in:
// TODO: add error check.
c.bw.Write(buf.Bytes())
if len(c.in) == 0 {
c.bw.Flush()
}
}
}
}
func (c *connection) call(request *call) error {
id := c.idGen.incrAndGet()
rh := &proto.RequestHeader{
CallId: pb.Uint32(uint32(id)),
MethodName: pb.String(request.methodName),
RequestParam: pb.Bool(true),
}
request.id = uint32(id)
bfrh := iohelper.NewPbBuffer()
err := bfrh.WritePBMessage(rh)
if err != nil {
return errors.Trace(err)
}
bfr := iohelper.NewPbBuffer()
err = bfr.WritePBMessage(request.request)
if err != nil {
return errors.Trace(err)
}
// Buf =>
// | total size | pb1 size | pb1 | pb2 size | pb2 | ...
buf := iohelper.NewPbBuffer()
buf.WriteDelimitedBuffers(bfrh, bfr)
c.mu.Lock()
c.ongoingCalls[id] = request
c.in <- buf
c.mu.Unlock()
return nil
}
func (c *connection) close() error {
return c.conn.Close()
}

113
vendor/github.com/pingcap/go-hbase/del.go generated vendored
View file

@ -1,113 +0,0 @@
package hbase
import (
pb "github.com/golang/protobuf/proto"
"github.com/pingcap/go-hbase/proto"
"fmt"
"math"
"strings"
)
type Delete struct {
Row []byte
Families set
FamilyQuals map[string]set
Ts map[string]uint64
}
func NewDelete(row []byte) *Delete {
return &Delete{
Row: row,
Families: newSet(),
FamilyQuals: make(map[string]set),
Ts: make(map[string]uint64),
}
}
func (d *Delete) AddString(famqual string) error {
parts := strings.Split(famqual, ":")
if len(parts) > 2 {
return fmt.Errorf("Too many colons were found in the family:qualifier string. '%s'", famqual)
} else if len(parts) == 2 {
d.AddStringColumn(parts[0], parts[1])
} else {
d.AddStringFamily(famqual)
}
return nil
}
func (d *Delete) GetRow() []byte {
return d.Row
}
func (d *Delete) AddColumn(family, qual []byte) *Delete {
d.AddFamily(family)
d.FamilyQuals[string(family)].add(string(qual))
return d
}
func (d *Delete) AddStringColumn(family, qual string) *Delete {
return d.AddColumn([]byte(family), []byte(qual))
}
func (d *Delete) AddFamily(family []byte) *Delete {
d.Families.add(string(family))
if _, ok := d.FamilyQuals[string(family)]; !ok {
d.FamilyQuals[string(family)] = newSet()
}
return d
}
func (d *Delete) AddStringFamily(family string) *Delete {
return d.AddFamily([]byte(family))
}
func (d *Delete) AddColumnWithTimestamp(family, qual []byte, ts uint64) *Delete {
d.AddColumn(family, qual)
k := string(family) + ":" + string(qual)
d.Ts[k] = ts
return d
}
func (d *Delete) ToProto() pb.Message {
del := &proto.MutationProto{
Row: d.Row,
MutateType: proto.MutationProto_DELETE.Enum(),
}
for family := range d.Families {
cv := &proto.MutationProto_ColumnValue{
Family: []byte(family),
QualifierValue: make([]*proto.MutationProto_ColumnValue_QualifierValue, 0),
}
if len(d.FamilyQuals[family]) == 0 {
cv.QualifierValue = append(cv.QualifierValue, &proto.MutationProto_ColumnValue_QualifierValue{
Qualifier: nil,
Timestamp: pb.Uint64(uint64(math.MaxInt64)),
DeleteType: proto.MutationProto_DELETE_FAMILY.Enum(),
})
}
for qual := range d.FamilyQuals[family] {
v := &proto.MutationProto_ColumnValue_QualifierValue{
Qualifier: []byte(qual),
Timestamp: pb.Uint64(uint64(math.MaxInt64)),
DeleteType: proto.MutationProto_DELETE_MULTIPLE_VERSIONS.Enum(),
}
tsKey := string(family) + ":" + string(qual)
if ts, ok := d.Ts[tsKey]; ok {
v.Timestamp = pb.Uint64(ts)
v.DeleteType = proto.MutationProto_DELETE_ONE_VERSION.Enum()
}
cv.QualifierValue = append(cv.QualifierValue, v)
}
del.ColumnValue = append(del.ColumnValue, cv)
}
return del
}

105
vendor/github.com/pingcap/go-hbase/get.go generated vendored
View file

@ -1,105 +0,0 @@
package hbase
import (
"strings"
pb "github.com/golang/protobuf/proto"
"github.com/juju/errors"
"github.com/pingcap/go-hbase/proto"
)
type Get struct {
Row []byte
Families set
FamilyQuals map[string]set
Versions int32
TsRangeFrom uint64
TsRangeTo uint64
}
func NewGet(row []byte) *Get {
return &Get{
Row: append([]byte(nil), row...),
Families: newSet(),
FamilyQuals: make(map[string]set),
Versions: 1,
}
}
func (g *Get) GetRow() []byte {
return g.Row
}
func (g *Get) AddString(famqual string) error {
parts := strings.Split(famqual, ":")
if len(parts) > 2 {
return errors.Errorf("Too many colons were found in the family:qualifier string. '%s'", famqual)
} else if len(parts) == 2 {
g.AddStringColumn(parts[0], parts[1])
} else {
g.AddStringFamily(famqual)
}
return nil
}
func (g *Get) AddColumn(family, qual []byte) *Get {
g.AddFamily(family)
g.FamilyQuals[string(family)].add(string(qual))
return g
}
func (g *Get) AddStringColumn(family, qual string) *Get {
return g.AddColumn([]byte(family), []byte(qual))
}
func (g *Get) AddFamily(family []byte) *Get {
g.Families.add(string(family))
if _, ok := g.FamilyQuals[string(family)]; !ok {
g.FamilyQuals[string(family)] = newSet()
}
return g
}
func (g *Get) AddStringFamily(family string) *Get {
return g.AddFamily([]byte(family))
}
func (g *Get) AddTimeRange(from uint64, to uint64) *Get {
g.TsRangeFrom = from
g.TsRangeTo = to
return g
}
func (g *Get) SetMaxVersion(maxVersion int32) *Get {
g.Versions = maxVersion
return g
}
func (g *Get) ToProto() pb.Message {
get := &proto.Get{
Row: g.Row,
}
if g.TsRangeFrom != 0 && g.TsRangeTo != 0 && g.TsRangeFrom <= g.TsRangeTo {
get.TimeRange = &proto.TimeRange{
From: pb.Uint64(g.TsRangeFrom),
To: pb.Uint64(g.TsRangeTo),
}
}
for v := range g.Families {
col := &proto.Column{
Family: []byte(v),
}
var quals [][]byte
for qual := range g.FamilyQuals[v] {
quals = append(quals, []byte(qual))
}
col.Qualifier = quals
get.Column = append(get.Column, col)
}
get.MaxVersions = pb.Uint32(uint32(g.Versions))
return get
}

8
vendor/github.com/pingcap/go-hbase/iohelper/multireader.go generated vendored
View file

@ -1,8 +0,0 @@
package iohelper
import "io"
type ByteMultiReader interface {
io.ByteReader
io.Reader
}

111
vendor/github.com/pingcap/go-hbase/iohelper/pbbuffer.go generated vendored
View file

@ -1,111 +0,0 @@
package iohelper
import (
"encoding/binary"
pb "github.com/golang/protobuf/proto"
"github.com/juju/errors"
)
type PbBuffer struct {
b []byte
}
func NewPbBuffer() *PbBuffer {
b := []byte{}
return &PbBuffer{
b: b,
}
}
func (b *PbBuffer) Bytes() []byte {
return b.b
}
func (b *PbBuffer) Write(d []byte) (int, error) {
b.b = append(b.b, d...)
return len(d), nil
}
func (b *PbBuffer) WriteByte(d byte) error {
return binary.Write(b, binary.BigEndian, d)
}
func (b *PbBuffer) WriteString(d string) error {
return binary.Write(b, binary.BigEndian, d)
}
func (b *PbBuffer) WriteInt32(d int32) error {
return binary.Write(b, binary.BigEndian, d)
}
func (b *PbBuffer) WriteInt64(d int64) error {
return binary.Write(b, binary.BigEndian, d)
}
func (b *PbBuffer) WriteFloat32(d float32) error {
return binary.Write(b, binary.BigEndian, d)
}
func (b *PbBuffer) WriteFloat64(d float64) error {
return binary.Write(b, binary.BigEndian, d)
}
func (b *PbBuffer) WritePBMessage(d pb.Message) error {
buf, err := pb.Marshal(d)
if err != nil {
return errors.Trace(err)
}
_, err = b.Write(buf)
return errors.Trace(err)
}
func (b *PbBuffer) WriteDelimitedBuffers(bufs ...*PbBuffer) error {
totalLength := 0
lens := make([][]byte, len(bufs))
for i, v := range bufs {
n := len(v.Bytes())
lenb := pb.EncodeVarint(uint64(n))
totalLength += len(lenb) + n
lens[i] = lenb
}
err := b.WriteInt32(int32(totalLength))
if err != nil {
return errors.Trace(err)
}
for i, v := range bufs {
_, err = b.Write(lens[i])
if err != nil {
return errors.Trace(err)
}
_, err = b.Write(v.Bytes())
if err != nil {
return errors.Trace(err)
}
}
return nil
}
func (b *PbBuffer) PrependSize() error {
size := int32(len(b.b))
newBuf := NewPbBuffer()
err := newBuf.WriteInt32(size)
if err != nil {
return errors.Trace(err)
}
_, err = newBuf.Write(b.b)
if err != nil {
return errors.Trace(err)
}
*b = *newBuf
return nil
}

177
vendor/github.com/pingcap/go-hbase/iohelper/utils.go generated vendored
View file

@ -1,177 +0,0 @@
package iohelper
import (
"bytes"
"encoding/binary"
"io"
"github.com/juju/errors"
)
var (
cachedItob [][]byte
)
func init() {
cachedItob = make([][]byte, 1024)
for i := 0; i < len(cachedItob); i++ {
var b bytes.Buffer
writeVLong(&b, int64(i))
cachedItob[i] = b.Bytes()
}
}
func itob(i int) ([]byte, error) {
if i >= 0 && i < len(cachedItob) {
return cachedItob[i], nil
}
var b bytes.Buffer
err := binary.Write(&b, binary.BigEndian, i)
if err != nil {
return nil, errors.Trace(err)
}
return b.Bytes(), nil
}
func decodeVIntSize(value byte) int32 {
if int32(value) >= -112 {
return int32(1)
}
if int32(value) < -120 {
return -119 - int32(value)
}
return -111 - int32(value)
}
func isNegativeVInt(value byte) bool {
return int32(value) < -120 || int32(value) >= -112 && int32(value) < 0
}
func readVLong(r io.Reader) (int64, error) {
var firstByte byte
err := binary.Read(r, binary.BigEndian, &firstByte)
if err != nil {
return 0, errors.Trace(err)
}
l := decodeVIntSize(firstByte)
if l == 1 {
return int64(firstByte), nil
}
var (
i int64
idx int32
)
for idx = 0; idx < l-1; idx++ {
var b byte
err = binary.Read(r, binary.BigEndian, &b)
if err != nil {
return 0, errors.Trace(err)
}
i <<= 8
i |= int64(b & 255)
}
if isNegativeVInt(firstByte) {
return ^i, nil
}
return i, nil
}
func writeVLong(w io.Writer, i int64) error {
var err error
if i >= -112 && i <= 127 {
err = binary.Write(w, binary.BigEndian, byte(i))
if err != nil {
return errors.Trace(err)
}
} else {
var l int32 = -112
if i < 0 {
i = ^i
l = -120
}
var tmp int64
for tmp = i; tmp != 0; l-- {
tmp >>= 8
}
err = binary.Write(w, binary.BigEndian, byte(l))
if err != nil {
return errors.Trace(err)
}
if l < -120 {
l = -(l + 120)
} else {
l = -(l + 112)
}
for idx := l; idx != 0; idx-- {
var mask int64
shiftbits := uint((idx - 1) * 8)
mask = int64(255) << shiftbits
err = binary.Write(w, binary.BigEndian, byte((i&mask)>>shiftbits))
if err != nil {
return errors.Trace(err)
}
}
}
return nil
}
func ReadVarBytes(r ByteMultiReader) ([]byte, error) {
sz, err := readVLong(r)
if err != nil {
return nil, errors.Trace(err)
}
b := make([]byte, sz)
_, err = r.Read(b)
if err != nil {
return nil, errors.Trace(err)
}
return b, nil
}
func WriteVarBytes(w io.Writer, b []byte) error {
lenb, err := itob(len(b))
if err != nil {
return errors.Trace(err)
}
_, err = w.Write(lenb)
if err != nil {
return errors.Trace(err)
}
_, err = w.Write(b)
return errors.Trace(err)
}
func ReadInt32(r io.Reader) (int32, error) {
var n int32
err := binary.Read(r, binary.BigEndian, &n)
return n, errors.Trace(err)
}
func ReadN(r io.Reader, n int32) ([]byte, error) {
b := make([]byte, n)
_, err := io.ReadFull(r, b)
return b, errors.Trace(err)
}
func ReadUint64(r io.Reader) (uint64, error) {
var n uint64
err := binary.Read(r, binary.BigEndian, &n)
return n, errors.Trace(err)
}

451
vendor/github.com/pingcap/go-hbase/proto/AccessControl.pb.go generated vendored
View file

@ -1,451 +0,0 @@
// Code generated by protoc-gen-go.
// source: AccessControl.proto
// DO NOT EDIT!
/*
Package proto is a generated protocol buffer package.
It is generated from these files:
AccessControl.proto
Admin.proto
Aggregate.proto
Authentication.proto
Cell.proto
Client.proto
ClusterId.proto
ClusterStatus.proto
Comparator.proto
Encryption.proto
ErrorHandling.proto
FS.proto
Filter.proto
HBase.proto
HFile.proto
LoadBalancer.proto
MapReduce.proto
Master.proto
MultiRowMutation.proto
RPC.proto
RegionServerStatus.proto
RowProcessor.proto
SecureBulkLoad.proto
Snapshot.proto
Themis.proto
Tracing.proto
VisibilityLabels.proto
WAL.proto
ZooKeeper.proto
It has these top-level messages:
Permission
TablePermission
NamespacePermission
GlobalPermission
UserPermission
UsersAndPermissions
GrantRequest
GrantResponse
RevokeRequest
RevokeResponse
GetUserPermissionsRequest
GetUserPermissionsResponse
CheckPermissionsRequest
CheckPermissionsResponse
*/
package proto
import proto1 "github.com/golang/protobuf/proto"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto1.Marshal
var _ = math.Inf
type Permission_Action int32
const (
Permission_READ Permission_Action = 0
Permission_WRITE Permission_Action = 1
Permission_EXEC Permission_Action = 2
Permission_CREATE Permission_Action = 3
Permission_ADMIN Permission_Action = 4
)
var Permission_Action_name = map[int32]string{
0: "READ",
1: "WRITE",
2: "EXEC",
3: "CREATE",
4: "ADMIN",
}
var Permission_Action_value = map[string]int32{
"READ": 0,
"WRITE": 1,
"EXEC": 2,
"CREATE": 3,
"ADMIN": 4,
}
func (x Permission_Action) Enum() *Permission_Action {
p := new(Permission_Action)
*p = x
return p
}
func (x Permission_Action) String() string {
return proto1.EnumName(Permission_Action_name, int32(x))
}
func (x *Permission_Action) UnmarshalJSON(data []byte) error {
value, err := proto1.UnmarshalJSONEnum(Permission_Action_value, data, "Permission_Action")
if err != nil {
return err
}
*x = Permission_Action(value)
return nil
}
type Permission_Type int32
const (
Permission_Global Permission_Type = 1
Permission_Namespace Permission_Type = 2
Permission_Table Permission_Type = 3
)
var Permission_Type_name = map[int32]string{
1: "Global",
2: "Namespace",
3: "Table",
}
var Permission_Type_value = map[string]int32{
"Global": 1,
"Namespace": 2,
"Table": 3,
}
func (x Permission_Type) Enum() *Permission_Type {
p := new(Permission_Type)
*p = x
return p
}
func (x Permission_Type) String() string {
return proto1.EnumName(Permission_Type_name, int32(x))
}
func (x *Permission_Type) UnmarshalJSON(data []byte) error {
value, err := proto1.UnmarshalJSONEnum(Permission_Type_value, data, "Permission_Type")
if err != nil {
return err
}
*x = Permission_Type(value)
return nil
}
type Permission struct {
Type *Permission_Type `protobuf:"varint,1,req,name=type,enum=proto.Permission_Type" json:"type,omitempty"`
GlobalPermission *GlobalPermission `protobuf:"bytes,2,opt,name=global_permission" json:"global_permission,omitempty"`
NamespacePermission *NamespacePermission `protobuf:"bytes,3,opt,name=namespace_permission" json:"namespace_permission,omitempty"`
TablePermission *TablePermission `protobuf:"bytes,4,opt,name=table_permission" json:"table_permission,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Permission) Reset() { *m = Permission{} }
func (m *Permission) String() string { return proto1.CompactTextString(m) }
func (*Permission) ProtoMessage() {}
func (m *Permission) GetType() Permission_Type {
if m != nil && m.Type != nil {
return *m.Type
}
return Permission_Global
}
func (m *Permission) GetGlobalPermission() *GlobalPermission {
if m != nil {
return m.GlobalPermission
}
return nil
}
func (m *Permission) GetNamespacePermission() *NamespacePermission {
if m != nil {
return m.NamespacePermission
}
return nil
}
func (m *Permission) GetTablePermission() *TablePermission {
if m != nil {
return m.TablePermission
}
return nil
}
type TablePermission struct {
TableName *TableName `protobuf:"bytes,1,opt,name=table_name" json:"table_name,omitempty"`
Family []byte `protobuf:"bytes,2,opt,name=family" json:"family,omitempty"`
Qualifier []byte `protobuf:"bytes,3,opt,name=qualifier" json:"qualifier,omitempty"`
Action []Permission_Action `protobuf:"varint,4,rep,name=action,enum=proto.Permission_Action" json:"action,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TablePermission) Reset() { *m = TablePermission{} }
func (m *TablePermission) String() string { return proto1.CompactTextString(m) }
func (*TablePermission) ProtoMessage() {}
func (m *TablePermission) GetTableName() *TableName {
if m != nil {
return m.TableName
}
return nil
}
func (m *TablePermission) GetFamily() []byte {
if m != nil {
return m.Family
}
return nil
}
func (m *TablePermission) GetQualifier() []byte {
if m != nil {
return m.Qualifier
}
return nil
}
func (m *TablePermission) GetAction() []Permission_Action {
if m != nil {
return m.Action
}
return nil
}
type NamespacePermission struct {
NamespaceName []byte `protobuf:"bytes,1,opt,name=namespace_name" json:"namespace_name,omitempty"`
Action []Permission_Action `protobuf:"varint,2,rep,name=action,enum=proto.Permission_Action" json:"action,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *NamespacePermission) Reset() { *m = NamespacePermission{} }
func (m *NamespacePermission) String() string { return proto1.CompactTextString(m) }
func (*NamespacePermission) ProtoMessage() {}
func (m *NamespacePermission) GetNamespaceName() []byte {
if m != nil {
return m.NamespaceName
}
return nil
}
func (m *NamespacePermission) GetAction() []Permission_Action {
if m != nil {
return m.Action
}
return nil
}
type GlobalPermission struct {
Action []Permission_Action `protobuf:"varint,1,rep,name=action,enum=proto.Permission_Action" json:"action,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GlobalPermission) Reset() { *m = GlobalPermission{} }
func (m *GlobalPermission) String() string { return proto1.CompactTextString(m) }
func (*GlobalPermission) ProtoMessage() {}
func (m *GlobalPermission) GetAction() []Permission_Action {
if m != nil {
return m.Action
}
return nil
}
type UserPermission struct {
User []byte `protobuf:"bytes,1,req,name=user" json:"user,omitempty"`
Permission *Permission `protobuf:"bytes,3,req,name=permission" json:"permission,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *UserPermission) Reset() { *m = UserPermission{} }
func (m *UserPermission) String() string { return proto1.CompactTextString(m) }
func (*UserPermission) ProtoMessage() {}
func (m *UserPermission) GetUser() []byte {
if m != nil {
return m.User
}
return nil
}
func (m *UserPermission) GetPermission() *Permission {
if m != nil {
return m.Permission
}
return nil
}
// *
// Content of the /hbase/acl/<table or namespace> znode.
type UsersAndPermissions struct {
UserPermissions []*UsersAndPermissions_UserPermissions `protobuf:"bytes,1,rep,name=user_permissions" json:"user_permissions,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *UsersAndPermissions) Reset() { *m = UsersAndPermissions{} }
func (m *UsersAndPermissions) String() string { return proto1.CompactTextString(m) }
func (*UsersAndPermissions) ProtoMessage() {}
func (m *UsersAndPermissions) GetUserPermissions() []*UsersAndPermissions_UserPermissions {
if m != nil {
return m.UserPermissions
}
return nil
}
type UsersAndPermissions_UserPermissions struct {
User []byte `protobuf:"bytes,1,req,name=user" json:"user,omitempty"`
Permissions []*Permission `protobuf:"bytes,2,rep,name=permissions" json:"permissions,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *UsersAndPermissions_UserPermissions) Reset() { *m = UsersAndPermissions_UserPermissions{} }
func (m *UsersAndPermissions_UserPermissions) String() string { return proto1.CompactTextString(m) }
func (*UsersAndPermissions_UserPermissions) ProtoMessage() {}
func (m *UsersAndPermissions_UserPermissions) GetUser() []byte {
if m != nil {
return m.User
}
return nil
}
func (m *UsersAndPermissions_UserPermissions) GetPermissions() []*Permission {
if m != nil {
return m.Permissions
}
return nil
}
type GrantRequest struct {
UserPermission *UserPermission `protobuf:"bytes,1,req,name=user_permission" json:"user_permission,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GrantRequest) Reset() { *m = GrantRequest{} }
func (m *GrantRequest) String() string { return proto1.CompactTextString(m) }
func (*GrantRequest) ProtoMessage() {}
func (m *GrantRequest) GetUserPermission() *UserPermission {
if m != nil {
return m.UserPermission
}
return nil
}
type GrantResponse struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *GrantResponse) Reset() { *m = GrantResponse{} }
func (m *GrantResponse) String() string { return proto1.CompactTextString(m) }
func (*GrantResponse) ProtoMessage() {}
type RevokeRequest struct {
UserPermission *UserPermission `protobuf:"bytes,1,req,name=user_permission" json:"user_permission,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *RevokeRequest) Reset() { *m = RevokeRequest{} }
func (m *RevokeRequest) String() string { return proto1.CompactTextString(m) }
func (*RevokeRequest) ProtoMessage() {}
func (m *RevokeRequest) GetUserPermission() *UserPermission {
if m != nil {
return m.UserPermission
}
return nil
}
type RevokeResponse struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *RevokeResponse) Reset() { *m = RevokeResponse{} }
func (m *RevokeResponse) String() string { return proto1.CompactTextString(m) }
func (*RevokeResponse) ProtoMessage() {}
type GetUserPermissionsRequest struct {
Type *Permission_Type `protobuf:"varint,1,opt,name=type,enum=proto.Permission_Type" json:"type,omitempty"`
TableName *TableName `protobuf:"bytes,2,opt,name=table_name" json:"table_name,omitempty"`
NamespaceName []byte `protobuf:"bytes,3,opt,name=namespace_name" json:"namespace_name,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GetUserPermissionsRequest) Reset() { *m = GetUserPermissionsRequest{} }
func (m *GetUserPermissionsRequest) String() string { return proto1.CompactTextString(m) }
func (*GetUserPermissionsRequest) ProtoMessage() {}
func (m *GetUserPermissionsRequest) GetType() Permission_Type {
if m != nil && m.Type != nil {
return *m.Type
}
return Permission_Global
}
func (m *GetUserPermissionsRequest) GetTableName() *TableName {
if m != nil {
return m.TableName
}
return nil
}
func (m *GetUserPermissionsRequest) GetNamespaceName() []byte {
if m != nil {
return m.NamespaceName
}
return nil
}
type GetUserPermissionsResponse struct {
UserPermission []*UserPermission `protobuf:"bytes,1,rep,name=user_permission" json:"user_permission,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GetUserPermissionsResponse) Reset() { *m = GetUserPermissionsResponse{} }
func (m *GetUserPermissionsResponse) String() string { return proto1.CompactTextString(m) }
func (*GetUserPermissionsResponse) ProtoMessage() {}
func (m *GetUserPermissionsResponse) GetUserPermission() []*UserPermission {
if m != nil {
return m.UserPermission
}
return nil
}
type CheckPermissionsRequest struct {
Permission []*Permission `protobuf:"bytes,1,rep,name=permission" json:"permission,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CheckPermissionsRequest) Reset() { *m = CheckPermissionsRequest{} }
func (m *CheckPermissionsRequest) String() string { return proto1.CompactTextString(m) }
func (*CheckPermissionsRequest) ProtoMessage() {}
func (m *CheckPermissionsRequest) GetPermission() []*Permission {
if m != nil {
return m.Permission
}
return nil
}
type CheckPermissionsResponse struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *CheckPermissionsResponse) Reset() { *m = CheckPermissionsResponse{} }
func (m *CheckPermissionsResponse) String() string { return proto1.CompactTextString(m) }
func (*CheckPermissionsResponse) ProtoMessage() {}
func init() {
proto1.RegisterEnum("proto.Permission_Action", Permission_Action_name, Permission_Action_value)
proto1.RegisterEnum("proto.Permission_Type", Permission_Type_name, Permission_Type_value)
}

769
vendor/github.com/pingcap/go-hbase/proto/Admin.pb.go generated vendored
View file

@ -1,769 +0,0 @@
// Code generated by protoc-gen-go.
// source: Admin.proto
// DO NOT EDIT!
package proto
import proto1 "github.com/golang/protobuf/proto"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto1.Marshal
var _ = math.Inf
type GetRegionInfoResponse_CompactionState int32
const (
GetRegionInfoResponse_NONE GetRegionInfoResponse_CompactionState = 0
GetRegionInfoResponse_MINOR GetRegionInfoResponse_CompactionState = 1
GetRegionInfoResponse_MAJOR GetRegionInfoResponse_CompactionState = 2
GetRegionInfoResponse_MAJOR_AND_MINOR GetRegionInfoResponse_CompactionState = 3
)
var GetRegionInfoResponse_CompactionState_name = map[int32]string{
0: "NONE",
1: "MINOR",
2: "MAJOR",
3: "MAJOR_AND_MINOR",
}
var GetRegionInfoResponse_CompactionState_value = map[string]int32{
"NONE": 0,
"MINOR": 1,
"MAJOR": 2,
"MAJOR_AND_MINOR": 3,
}
func (x GetRegionInfoResponse_CompactionState) Enum() *GetRegionInfoResponse_CompactionState {
p := new(GetRegionInfoResponse_CompactionState)
*p = x
return p
}
func (x GetRegionInfoResponse_CompactionState) String() string {
return proto1.EnumName(GetRegionInfoResponse_CompactionState_name, int32(x))
}
func (x *GetRegionInfoResponse_CompactionState) UnmarshalJSON(data []byte) error {
value, err := proto1.UnmarshalJSONEnum(GetRegionInfoResponse_CompactionState_value, data, "GetRegionInfoResponse_CompactionState")
if err != nil {
return err
}
*x = GetRegionInfoResponse_CompactionState(value)
return nil
}
type OpenRegionResponse_RegionOpeningState int32
const (
OpenRegionResponse_OPENED OpenRegionResponse_RegionOpeningState = 0
OpenRegionResponse_ALREADY_OPENED OpenRegionResponse_RegionOpeningState = 1
OpenRegionResponse_FAILED_OPENING OpenRegionResponse_RegionOpeningState = 2
)
var OpenRegionResponse_RegionOpeningState_name = map[int32]string{
0: "OPENED",
1: "ALREADY_OPENED",
2: "FAILED_OPENING",
}
var OpenRegionResponse_RegionOpeningState_value = map[string]int32{
"OPENED": 0,
"ALREADY_OPENED": 1,
"FAILED_OPENING": 2,
}
func (x OpenRegionResponse_RegionOpeningState) Enum() *OpenRegionResponse_RegionOpeningState {
p := new(OpenRegionResponse_RegionOpeningState)
*p = x
return p
}
func (x OpenRegionResponse_RegionOpeningState) String() string {
return proto1.EnumName(OpenRegionResponse_RegionOpeningState_name, int32(x))
}
func (x *OpenRegionResponse_RegionOpeningState) UnmarshalJSON(data []byte) error {
value, err := proto1.UnmarshalJSONEnum(OpenRegionResponse_RegionOpeningState_value, data, "OpenRegionResponse_RegionOpeningState")
if err != nil {
return err
}
*x = OpenRegionResponse_RegionOpeningState(value)
return nil
}
type GetRegionInfoRequest struct {
Region *RegionSpecifier `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
CompactionState *bool `protobuf:"varint,2,opt,name=compaction_state" json:"compaction_state,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GetRegionInfoRequest) Reset() { *m = GetRegionInfoRequest{} }
func (m *GetRegionInfoRequest) String() string { return proto1.CompactTextString(m) }
func (*GetRegionInfoRequest) ProtoMessage() {}
func (m *GetRegionInfoRequest) GetRegion() *RegionSpecifier {
if m != nil {
return m.Region
}
return nil
}
func (m *GetRegionInfoRequest) GetCompactionState() bool {
if m != nil && m.CompactionState != nil {
return *m.CompactionState
}
return false
}
type GetRegionInfoResponse struct {
RegionInfo *RegionInfo `protobuf:"bytes,1,req,name=region_info" json:"region_info,omitempty"`
CompactionState *GetRegionInfoResponse_CompactionState `protobuf:"varint,2,opt,name=compaction_state,enum=proto.GetRegionInfoResponse_CompactionState" json:"compaction_state,omitempty"`
IsRecovering *bool `protobuf:"varint,3,opt,name=isRecovering" json:"isRecovering,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GetRegionInfoResponse) Reset() { *m = GetRegionInfoResponse{} }
func (m *GetRegionInfoResponse) String() string { return proto1.CompactTextString(m) }
func (*GetRegionInfoResponse) ProtoMessage() {}
func (m *GetRegionInfoResponse) GetRegionInfo() *RegionInfo {
if m != nil {
return m.RegionInfo
}
return nil
}
func (m *GetRegionInfoResponse) GetCompactionState() GetRegionInfoResponse_CompactionState {
if m != nil && m.CompactionState != nil {
return *m.CompactionState
}
return GetRegionInfoResponse_NONE
}
func (m *GetRegionInfoResponse) GetIsRecovering() bool {
if m != nil && m.IsRecovering != nil {
return *m.IsRecovering
}
return false
}
// *
// Get a list of store files for a set of column families in a particular region.
// If no column family is specified, get the store files for all column families.
type GetStoreFileRequest struct {
Region *RegionSpecifier `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
Family [][]byte `protobuf:"bytes,2,rep,name=family" json:"family,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GetStoreFileRequest) Reset() { *m = GetStoreFileRequest{} }
func (m *GetStoreFileRequest) String() string { return proto1.CompactTextString(m) }
func (*GetStoreFileRequest) ProtoMessage() {}
func (m *GetStoreFileRequest) GetRegion() *RegionSpecifier {
if m != nil {
return m.Region
}
return nil
}
func (m *GetStoreFileRequest) GetFamily() [][]byte {
if m != nil {
return m.Family
}
return nil
}
type GetStoreFileResponse struct {
StoreFile []string `protobuf:"bytes,1,rep,name=store_file" json:"store_file,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GetStoreFileResponse) Reset() { *m = GetStoreFileResponse{} }
func (m *GetStoreFileResponse) String() string { return proto1.CompactTextString(m) }
func (*GetStoreFileResponse) ProtoMessage() {}
func (m *GetStoreFileResponse) GetStoreFile() []string {
if m != nil {
return m.StoreFile
}
return nil
}
type GetOnlineRegionRequest struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *GetOnlineRegionRequest) Reset() { *m = GetOnlineRegionRequest{} }
func (m *GetOnlineRegionRequest) String() string { return proto1.CompactTextString(m) }
func (*GetOnlineRegionRequest) ProtoMessage() {}
type GetOnlineRegionResponse struct {
RegionInfo []*RegionInfo `protobuf:"bytes,1,rep,name=region_info" json:"region_info,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GetOnlineRegionResponse) Reset() { *m = GetOnlineRegionResponse{} }
func (m *GetOnlineRegionResponse) String() string { return proto1.CompactTextString(m) }
func (*GetOnlineRegionResponse) ProtoMessage() {}
func (m *GetOnlineRegionResponse) GetRegionInfo() []*RegionInfo {
if m != nil {
return m.RegionInfo
}
return nil
}
type OpenRegionRequest struct {
OpenInfo []*OpenRegionRequest_RegionOpenInfo `protobuf:"bytes,1,rep,name=open_info" json:"open_info,omitempty"`
// the intended server for this RPC.
ServerStartCode *uint64 `protobuf:"varint,2,opt,name=serverStartCode" json:"serverStartCode,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *OpenRegionRequest) Reset() { *m = OpenRegionRequest{} }
func (m *OpenRegionRequest) String() string { return proto1.CompactTextString(m) }
func (*OpenRegionRequest) ProtoMessage() {}
func (m *OpenRegionRequest) GetOpenInfo() []*OpenRegionRequest_RegionOpenInfo {
if m != nil {
return m.OpenInfo
}
return nil
}
func (m *OpenRegionRequest) GetServerStartCode() uint64 {
if m != nil && m.ServerStartCode != nil {
return *m.ServerStartCode
}
return 0
}
type OpenRegionRequest_RegionOpenInfo struct {
Region *RegionInfo `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
VersionOfOfflineNode *uint32 `protobuf:"varint,2,opt,name=version_of_offline_node" json:"version_of_offline_node,omitempty"`
FavoredNodes []*ServerName `protobuf:"bytes,3,rep,name=favored_nodes" json:"favored_nodes,omitempty"`
// open region for distributedLogReplay
OpenForDistributedLogReplay *bool `protobuf:"varint,4,opt,name=openForDistributedLogReplay" json:"openForDistributedLogReplay,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *OpenRegionRequest_RegionOpenInfo) Reset() { *m = OpenRegionRequest_RegionOpenInfo{} }
func (m *OpenRegionRequest_RegionOpenInfo) String() string { return proto1.CompactTextString(m) }
func (*OpenRegionRequest_RegionOpenInfo) ProtoMessage() {}
func (m *OpenRegionRequest_RegionOpenInfo) GetRegion() *RegionInfo {
if m != nil {
return m.Region
}
return nil
}
func (m *OpenRegionRequest_RegionOpenInfo) GetVersionOfOfflineNode() uint32 {
if m != nil && m.VersionOfOfflineNode != nil {
return *m.VersionOfOfflineNode
}
return 0
}
func (m *OpenRegionRequest_RegionOpenInfo) GetFavoredNodes() []*ServerName {
if m != nil {
return m.FavoredNodes
}
return nil
}
func (m *OpenRegionRequest_RegionOpenInfo) GetOpenForDistributedLogReplay() bool {
if m != nil && m.OpenForDistributedLogReplay != nil {
return *m.OpenForDistributedLogReplay
}
return false
}
type OpenRegionResponse struct {
OpeningState []OpenRegionResponse_RegionOpeningState `protobuf:"varint,1,rep,name=opening_state,enum=proto.OpenRegionResponse_RegionOpeningState" json:"opening_state,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *OpenRegionResponse) Reset() { *m = OpenRegionResponse{} }
func (m *OpenRegionResponse) String() string { return proto1.CompactTextString(m) }
func (*OpenRegionResponse) ProtoMessage() {}
func (m *OpenRegionResponse) GetOpeningState() []OpenRegionResponse_RegionOpeningState {
if m != nil {
return m.OpeningState
}
return nil
}
// *
// Closes the specified region and will use or not use ZK during the close
// according to the specified flag.
type CloseRegionRequest struct {
Region *RegionSpecifier `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
VersionOfClosingNode *uint32 `protobuf:"varint,2,opt,name=version_of_closing_node" json:"version_of_closing_node,omitempty"`
TransitionIn_ZK *bool `protobuf:"varint,3,opt,name=transition_in_ZK,def=1" json:"transition_in_ZK,omitempty"`
DestinationServer *ServerName `protobuf:"bytes,4,opt,name=destination_server" json:"destination_server,omitempty"`
// the intended server for this RPC.
ServerStartCode *uint64 `protobuf:"varint,5,opt,name=serverStartCode" json:"serverStartCode,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CloseRegionRequest) Reset() { *m = CloseRegionRequest{} }
func (m *CloseRegionRequest) String() string { return proto1.CompactTextString(m) }
func (*CloseRegionRequest) ProtoMessage() {}
const Default_CloseRegionRequest_TransitionIn_ZK bool = true
func (m *CloseRegionRequest) GetRegion() *RegionSpecifier {
if m != nil {
return m.Region
}
return nil
}
func (m *CloseRegionRequest) GetVersionOfClosingNode() uint32 {
if m != nil && m.VersionOfClosingNode != nil {
return *m.VersionOfClosingNode
}
return 0
}
func (m *CloseRegionRequest) GetTransitionIn_ZK() bool {
if m != nil && m.TransitionIn_ZK != nil {
return *m.TransitionIn_ZK
}
return Default_CloseRegionRequest_TransitionIn_ZK
}
func (m *CloseRegionRequest) GetDestinationServer() *ServerName {
if m != nil {
return m.DestinationServer
}
return nil
}
func (m *CloseRegionRequest) GetServerStartCode() uint64 {
if m != nil && m.ServerStartCode != nil {
return *m.ServerStartCode
}
return 0
}
type CloseRegionResponse struct {
Closed *bool `protobuf:"varint,1,req,name=closed" json:"closed,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CloseRegionResponse) Reset() { *m = CloseRegionResponse{} }
func (m *CloseRegionResponse) String() string { return proto1.CompactTextString(m) }
func (*CloseRegionResponse) ProtoMessage() {}
func (m *CloseRegionResponse) GetClosed() bool {
if m != nil && m.Closed != nil {
return *m.Closed
}
return false
}
// *
// Flushes the MemStore of the specified region.
// <p>
// This method is synchronous.
type FlushRegionRequest struct {
Region *RegionSpecifier `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
IfOlderThanTs *uint64 `protobuf:"varint,2,opt,name=if_older_than_ts" json:"if_older_than_ts,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *FlushRegionRequest) Reset() { *m = FlushRegionRequest{} }
func (m *FlushRegionRequest) String() string { return proto1.CompactTextString(m) }
func (*FlushRegionRequest) ProtoMessage() {}
func (m *FlushRegionRequest) GetRegion() *RegionSpecifier {
if m != nil {
return m.Region
}
return nil
}
func (m *FlushRegionRequest) GetIfOlderThanTs() uint64 {
if m != nil && m.IfOlderThanTs != nil {
return *m.IfOlderThanTs
}
return 0
}
type FlushRegionResponse struct {
LastFlushTime *uint64 `protobuf:"varint,1,req,name=last_flush_time" json:"last_flush_time,omitempty"`
Flushed *bool `protobuf:"varint,2,opt,name=flushed" json:"flushed,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *FlushRegionResponse) Reset() { *m = FlushRegionResponse{} }
func (m *FlushRegionResponse) String() string { return proto1.CompactTextString(m) }
func (*FlushRegionResponse) ProtoMessage() {}
func (m *FlushRegionResponse) GetLastFlushTime() uint64 {
if m != nil && m.LastFlushTime != nil {
return *m.LastFlushTime
}
return 0
}
func (m *FlushRegionResponse) GetFlushed() bool {
if m != nil && m.Flushed != nil {
return *m.Flushed
}
return false
}
// *
// Splits the specified region.
// <p>
// This method currently flushes the region and then forces a compaction which
// will then trigger a split. The flush is done synchronously but the
// compaction is asynchronous.
type SplitRegionRequest struct {
Region *RegionSpecifier `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
SplitPoint []byte `protobuf:"bytes,2,opt,name=split_point" json:"split_point,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *SplitRegionRequest) Reset() { *m = SplitRegionRequest{} }
func (m *SplitRegionRequest) String() string { return proto1.CompactTextString(m) }
func (*SplitRegionRequest) ProtoMessage() {}
func (m *SplitRegionRequest) GetRegion() *RegionSpecifier {
if m != nil {
return m.Region
}
return nil
}
func (m *SplitRegionRequest) GetSplitPoint() []byte {
if m != nil {
return m.SplitPoint
}
return nil
}
type SplitRegionResponse struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *SplitRegionResponse) Reset() { *m = SplitRegionResponse{} }
func (m *SplitRegionResponse) String() string { return proto1.CompactTextString(m) }
func (*SplitRegionResponse) ProtoMessage() {}
// *
// Compacts the specified region. Performs a major compaction if specified.
// <p>
// This method is asynchronous.
type CompactRegionRequest struct {
Region *RegionSpecifier `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
Major *bool `protobuf:"varint,2,opt,name=major" json:"major,omitempty"`
Family []byte `protobuf:"bytes,3,opt,name=family" json:"family,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CompactRegionRequest) Reset() { *m = CompactRegionRequest{} }
func (m *CompactRegionRequest) String() string { return proto1.CompactTextString(m) }
func (*CompactRegionRequest) ProtoMessage() {}
func (m *CompactRegionRequest) GetRegion() *RegionSpecifier {
if m != nil {
return m.Region
}
return nil
}
func (m *CompactRegionRequest) GetMajor() bool {
if m != nil && m.Major != nil {
return *m.Major
}
return false
}
func (m *CompactRegionRequest) GetFamily() []byte {
if m != nil {
return m.Family
}
return nil
}
type CompactRegionResponse struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *CompactRegionResponse) Reset() { *m = CompactRegionResponse{} }
func (m *CompactRegionResponse) String() string { return proto1.CompactTextString(m) }
func (*CompactRegionResponse) ProtoMessage() {}
type UpdateFavoredNodesRequest struct {
UpdateInfo []*UpdateFavoredNodesRequest_RegionUpdateInfo `protobuf:"bytes,1,rep,name=update_info" json:"update_info,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *UpdateFavoredNodesRequest) Reset() { *m = UpdateFavoredNodesRequest{} }
func (m *UpdateFavoredNodesRequest) String() string { return proto1.CompactTextString(m) }
func (*UpdateFavoredNodesRequest) ProtoMessage() {}
func (m *UpdateFavoredNodesRequest) GetUpdateInfo() []*UpdateFavoredNodesRequest_RegionUpdateInfo {
if m != nil {
return m.UpdateInfo
}
return nil
}
type UpdateFavoredNodesRequest_RegionUpdateInfo struct {
Region *RegionInfo `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
FavoredNodes []*ServerName `protobuf:"bytes,2,rep,name=favored_nodes" json:"favored_nodes,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *UpdateFavoredNodesRequest_RegionUpdateInfo) Reset() {
*m = UpdateFavoredNodesRequest_RegionUpdateInfo{}
}
func (m *UpdateFavoredNodesRequest_RegionUpdateInfo) String() string {
return proto1.CompactTextString(m)
}
func (*UpdateFavoredNodesRequest_RegionUpdateInfo) ProtoMessage() {}
func (m *UpdateFavoredNodesRequest_RegionUpdateInfo) GetRegion() *RegionInfo {
if m != nil {
return m.Region
}
return nil
}
func (m *UpdateFavoredNodesRequest_RegionUpdateInfo) GetFavoredNodes() []*ServerName {
if m != nil {
return m.FavoredNodes
}
return nil
}
type UpdateFavoredNodesResponse struct {
Response *uint32 `protobuf:"varint,1,opt,name=response" json:"response,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *UpdateFavoredNodesResponse) Reset() { *m = UpdateFavoredNodesResponse{} }
func (m *UpdateFavoredNodesResponse) String() string { return proto1.CompactTextString(m) }
func (*UpdateFavoredNodesResponse) ProtoMessage() {}
func (m *UpdateFavoredNodesResponse) GetResponse() uint32 {
if m != nil && m.Response != nil {
return *m.Response
}
return 0
}
// *
// Merges the specified regions.
// <p>
// This method currently closes the regions and then merges them
type MergeRegionsRequest struct {
RegionA *RegionSpecifier `protobuf:"bytes,1,req,name=region_a" json:"region_a,omitempty"`
RegionB *RegionSpecifier `protobuf:"bytes,2,req,name=region_b" json:"region_b,omitempty"`
Forcible *bool `protobuf:"varint,3,opt,name=forcible,def=0" json:"forcible,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *MergeRegionsRequest) Reset() { *m = MergeRegionsRequest{} }
func (m *MergeRegionsRequest) String() string { return proto1.CompactTextString(m) }
func (*MergeRegionsRequest) ProtoMessage() {}
const Default_MergeRegionsRequest_Forcible bool = false
func (m *MergeRegionsRequest) GetRegionA() *RegionSpecifier {
if m != nil {
return m.RegionA
}
return nil
}
func (m *MergeRegionsRequest) GetRegionB() *RegionSpecifier {
if m != nil {
return m.RegionB
}
return nil
}
func (m *MergeRegionsRequest) GetForcible() bool {
if m != nil && m.Forcible != nil {
return *m.Forcible
}
return Default_MergeRegionsRequest_Forcible
}
type MergeRegionsResponse struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *MergeRegionsResponse) Reset() { *m = MergeRegionsResponse{} }
func (m *MergeRegionsResponse) String() string { return proto1.CompactTextString(m) }
func (*MergeRegionsResponse) ProtoMessage() {}
// Protocol buffer version of WAL for replication
type WALEntry struct {
Key *WALKey `protobuf:"bytes,1,req,name=key" json:"key,omitempty"`
// Following may be null if the KVs/Cells are carried along the side in a cellblock (See
// RPC for more on cellblocks). If Cells/KVs are in a cellblock, this next field is null
// and associated_cell_count has count of Cells associated w/ this WALEntry
KeyValueBytes [][]byte `protobuf:"bytes,2,rep,name=key_value_bytes" json:"key_value_bytes,omitempty"`
// If Cell data is carried alongside in a cellblock, this is count of Cells in the cellblock.
AssociatedCellCount *int32 `protobuf:"varint,3,opt,name=associated_cell_count" json:"associated_cell_count,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *WALEntry) Reset() { *m = WALEntry{} }
func (m *WALEntry) String() string { return proto1.CompactTextString(m) }
func (*WALEntry) ProtoMessage() {}
func (m *WALEntry) GetKey() *WALKey {
if m != nil {
return m.Key
}
return nil
}
func (m *WALEntry) GetKeyValueBytes() [][]byte {
if m != nil {
return m.KeyValueBytes
}
return nil
}
func (m *WALEntry) GetAssociatedCellCount() int32 {
if m != nil && m.AssociatedCellCount != nil {
return *m.AssociatedCellCount
}
return 0
}
// *
// Replicates the given entries. The guarantee is that the given entries
// will be durable on the slave cluster if this method returns without
// any exception. hbase.replication has to be set to true for this to work.
type ReplicateWALEntryRequest struct {
Entry []*WALEntry `protobuf:"bytes,1,rep,name=entry" json:"entry,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ReplicateWALEntryRequest) Reset() { *m = ReplicateWALEntryRequest{} }
func (m *ReplicateWALEntryRequest) String() string { return proto1.CompactTextString(m) }
func (*ReplicateWALEntryRequest) ProtoMessage() {}
func (m *ReplicateWALEntryRequest) GetEntry() []*WALEntry {
if m != nil {
return m.Entry
}
return nil
}
type ReplicateWALEntryResponse struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *ReplicateWALEntryResponse) Reset() { *m = ReplicateWALEntryResponse{} }
func (m *ReplicateWALEntryResponse) String() string { return proto1.CompactTextString(m) }
func (*ReplicateWALEntryResponse) ProtoMessage() {}
type RollWALWriterRequest struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *RollWALWriterRequest) Reset() { *m = RollWALWriterRequest{} }
func (m *RollWALWriterRequest) String() string { return proto1.CompactTextString(m) }
func (*RollWALWriterRequest) ProtoMessage() {}
type RollWALWriterResponse struct {
// A list of encoded name of regions to flush
RegionToFlush [][]byte `protobuf:"bytes,1,rep,name=region_to_flush" json:"region_to_flush,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *RollWALWriterResponse) Reset() { *m = RollWALWriterResponse{} }
func (m *RollWALWriterResponse) String() string { return proto1.CompactTextString(m) }
func (*RollWALWriterResponse) ProtoMessage() {}
func (m *RollWALWriterResponse) GetRegionToFlush() [][]byte {
if m != nil {
return m.RegionToFlush
}
return nil
}
type StopServerRequest struct {
Reason *string `protobuf:"bytes,1,req,name=reason" json:"reason,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *StopServerRequest) Reset() { *m = StopServerRequest{} }
func (m *StopServerRequest) String() string { return proto1.CompactTextString(m) }
func (*StopServerRequest) ProtoMessage() {}
func (m *StopServerRequest) GetReason() string {
if m != nil && m.Reason != nil {
return *m.Reason
}
return ""
}
type StopServerResponse struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *StopServerResponse) Reset() { *m = StopServerResponse{} }
func (m *StopServerResponse) String() string { return proto1.CompactTextString(m) }
func (*StopServerResponse) ProtoMessage() {}
type GetServerInfoRequest struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *GetServerInfoRequest) Reset() { *m = GetServerInfoRequest{} }
func (m *GetServerInfoRequest) String() string { return proto1.CompactTextString(m) }
func (*GetServerInfoRequest) ProtoMessage() {}
type ServerInfo struct {
ServerName *ServerName `protobuf:"bytes,1,req,name=server_name" json:"server_name,omitempty"`
WebuiPort *uint32 `protobuf:"varint,2,opt,name=webui_port" json:"webui_port,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ServerInfo) Reset() { *m = ServerInfo{} }
func (m *ServerInfo) String() string { return proto1.CompactTextString(m) }
func (*ServerInfo) ProtoMessage() {}
func (m *ServerInfo) GetServerName() *ServerName {
if m != nil {
return m.ServerName
}
return nil
}
func (m *ServerInfo) GetWebuiPort() uint32 {
if m != nil && m.WebuiPort != nil {
return *m.WebuiPort
}
return 0
}
type GetServerInfoResponse struct {
ServerInfo *ServerInfo `protobuf:"bytes,1,req,name=server_info" json:"server_info,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GetServerInfoResponse) Reset() { *m = GetServerInfoResponse{} }
func (m *GetServerInfoResponse) String() string { return proto1.CompactTextString(m) }
func (*GetServerInfoResponse) ProtoMessage() {}
func (m *GetServerInfoResponse) GetServerInfo() *ServerInfo {
if m != nil {
return m.ServerInfo
}
return nil
}
func init() {
proto1.RegisterEnum("proto.GetRegionInfoResponse_CompactionState", GetRegionInfoResponse_CompactionState_name, GetRegionInfoResponse_CompactionState_value)
proto1.RegisterEnum("proto.OpenRegionResponse_RegionOpeningState", OpenRegionResponse_RegionOpeningState_name, OpenRegionResponse_RegionOpeningState_value)
}

82
vendor/github.com/pingcap/go-hbase/proto/Aggregate.pb.go generated vendored
View file

@ -1,82 +0,0 @@
// Code generated by protoc-gen-go.
// source: Aggregate.proto
// DO NOT EDIT!
package proto
import proto1 "github.com/golang/protobuf/proto"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto1.Marshal
var _ = math.Inf
type AggregateRequest struct {
// * The request passed to the AggregateService consists of three parts
// (1) the (canonical) classname of the ColumnInterpreter implementation
// (2) the Scan query
// (3) any bytes required to construct the ColumnInterpreter object
// properly
InterpreterClassName *string `protobuf:"bytes,1,req,name=interpreter_class_name" json:"interpreter_class_name,omitempty"`
Scan *Scan `protobuf:"bytes,2,req,name=scan" json:"scan,omitempty"`
InterpreterSpecificBytes []byte `protobuf:"bytes,3,opt,name=interpreter_specific_bytes" json:"interpreter_specific_bytes,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *AggregateRequest) Reset() { *m = AggregateRequest{} }
func (m *AggregateRequest) String() string { return proto1.CompactTextString(m) }
func (*AggregateRequest) ProtoMessage() {}
func (m *AggregateRequest) GetInterpreterClassName() string {
if m != nil && m.InterpreterClassName != nil {
return *m.InterpreterClassName
}
return ""
}
func (m *AggregateRequest) GetScan() *Scan {
if m != nil {
return m.Scan
}
return nil
}
func (m *AggregateRequest) GetInterpreterSpecificBytes() []byte {
if m != nil {
return m.InterpreterSpecificBytes
}
return nil
}
type AggregateResponse struct {
// *
// The AggregateService methods all have a response that either is a Pair
// or a simple object. When it is a Pair both first_part and second_part
// have defined values (and the second_part is not present in the response
// when the response is not a pair). Refer to the AggregateImplementation
// class for an overview of the AggregateResponse object constructions.
FirstPart [][]byte `protobuf:"bytes,1,rep,name=first_part" json:"first_part,omitempty"`
SecondPart []byte `protobuf:"bytes,2,opt,name=second_part" json:"second_part,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *AggregateResponse) Reset() { *m = AggregateResponse{} }
func (m *AggregateResponse) String() string { return proto1.CompactTextString(m) }
func (*AggregateResponse) ProtoMessage() {}
func (m *AggregateResponse) GetFirstPart() [][]byte {
if m != nil {
return m.FirstPart
}
return nil
}
func (m *AggregateResponse) GetSecondPart() []byte {
if m != nil {
return m.SecondPart
}
return nil
}
func init() {
}

228
vendor/github.com/pingcap/go-hbase/proto/Authentication.pb.go generated vendored
View file

@ -1,228 +0,0 @@
// Code generated by protoc-gen-go.
// source: Authentication.proto
// DO NOT EDIT!
package proto
import proto1 "github.com/golang/protobuf/proto"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto1.Marshal
var _ = math.Inf
type TokenIdentifier_Kind int32
const (
TokenIdentifier_HBASE_AUTH_TOKEN TokenIdentifier_Kind = 0
)
var TokenIdentifier_Kind_name = map[int32]string{
0: "HBASE_AUTH_TOKEN",
}
var TokenIdentifier_Kind_value = map[string]int32{
"HBASE_AUTH_TOKEN": 0,
}
func (x TokenIdentifier_Kind) Enum() *TokenIdentifier_Kind {
p := new(TokenIdentifier_Kind)
*p = x
return p
}
func (x TokenIdentifier_Kind) String() string {
return proto1.EnumName(TokenIdentifier_Kind_name, int32(x))
}
func (x *TokenIdentifier_Kind) UnmarshalJSON(data []byte) error {
value, err := proto1.UnmarshalJSONEnum(TokenIdentifier_Kind_value, data, "TokenIdentifier_Kind")
if err != nil {
return err
}
*x = TokenIdentifier_Kind(value)
return nil
}
type AuthenticationKey struct {
Id *int32 `protobuf:"varint,1,req,name=id" json:"id,omitempty"`
ExpirationDate *int64 `protobuf:"varint,2,req,name=expiration_date" json:"expiration_date,omitempty"`
Key []byte `protobuf:"bytes,3,req,name=key" json:"key,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *AuthenticationKey) Reset() { *m = AuthenticationKey{} }
func (m *AuthenticationKey) String() string { return proto1.CompactTextString(m) }
func (*AuthenticationKey) ProtoMessage() {}
func (m *AuthenticationKey) GetId() int32 {
if m != nil && m.Id != nil {
return *m.Id
}
return 0
}
func (m *AuthenticationKey) GetExpirationDate() int64 {
if m != nil && m.ExpirationDate != nil {
return *m.ExpirationDate
}
return 0
}
func (m *AuthenticationKey) GetKey() []byte {
if m != nil {
return m.Key
}
return nil
}
type TokenIdentifier struct {
Kind *TokenIdentifier_Kind `protobuf:"varint,1,req,name=kind,enum=proto.TokenIdentifier_Kind" json:"kind,omitempty"`
Username []byte `protobuf:"bytes,2,req,name=username" json:"username,omitempty"`
KeyId *int32 `protobuf:"varint,3,req,name=key_id" json:"key_id,omitempty"`
IssueDate *int64 `protobuf:"varint,4,opt,name=issue_date" json:"issue_date,omitempty"`
ExpirationDate *int64 `protobuf:"varint,5,opt,name=expiration_date" json:"expiration_date,omitempty"`
SequenceNumber *int64 `protobuf:"varint,6,opt,name=sequence_number" json:"sequence_number,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TokenIdentifier) Reset() { *m = TokenIdentifier{} }
func (m *TokenIdentifier) String() string { return proto1.CompactTextString(m) }
func (*TokenIdentifier) ProtoMessage() {}
func (m *TokenIdentifier) GetKind() TokenIdentifier_Kind {
if m != nil && m.Kind != nil {
return *m.Kind
}
return TokenIdentifier_HBASE_AUTH_TOKEN
}
func (m *TokenIdentifier) GetUsername() []byte {
if m != nil {
return m.Username
}
return nil
}
func (m *TokenIdentifier) GetKeyId() int32 {
if m != nil && m.KeyId != nil {
return *m.KeyId
}
return 0
}
func (m *TokenIdentifier) GetIssueDate() int64 {
if m != nil && m.IssueDate != nil {
return *m.IssueDate
}
return 0
}
func (m *TokenIdentifier) GetExpirationDate() int64 {
if m != nil && m.ExpirationDate != nil {
return *m.ExpirationDate
}
return 0
}
func (m *TokenIdentifier) GetSequenceNumber() int64 {
if m != nil && m.SequenceNumber != nil {
return *m.SequenceNumber
}
return 0
}
// Serialization of the org.apache.hadoop.security.token.Token class
// Note that this is a Hadoop class, so fields may change!
type Token struct {
// the TokenIdentifier in serialized form
// Note: we can't use the protobuf directly because the Hadoop Token class
// only stores the serialized bytes
Identifier []byte `protobuf:"bytes,1,opt,name=identifier" json:"identifier,omitempty"`
Password []byte `protobuf:"bytes,2,opt,name=password" json:"password,omitempty"`
Service []byte `protobuf:"bytes,3,opt,name=service" json:"service,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Token) Reset() { *m = Token{} }
func (m *Token) String() string { return proto1.CompactTextString(m) }
func (*Token) ProtoMessage() {}
func (m *Token) GetIdentifier() []byte {
if m != nil {
return m.Identifier
}
return nil
}
func (m *Token) GetPassword() []byte {
if m != nil {
return m.Password
}
return nil
}
func (m *Token) GetService() []byte {
if m != nil {
return m.Service
}
return nil
}
// RPC request & response messages
type GetAuthenticationTokenRequest struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *GetAuthenticationTokenRequest) Reset() { *m = GetAuthenticationTokenRequest{} }
func (m *GetAuthenticationTokenRequest) String() string { return proto1.CompactTextString(m) }
func (*GetAuthenticationTokenRequest) ProtoMessage() {}
type GetAuthenticationTokenResponse struct {
Token *Token `protobuf:"bytes,1,opt,name=token" json:"token,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GetAuthenticationTokenResponse) Reset() { *m = GetAuthenticationTokenResponse{} }
func (m *GetAuthenticationTokenResponse) String() string { return proto1.CompactTextString(m) }
func (*GetAuthenticationTokenResponse) ProtoMessage() {}
func (m *GetAuthenticationTokenResponse) GetToken() *Token {
if m != nil {
return m.Token
}
return nil
}
type WhoAmIRequest struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *WhoAmIRequest) Reset() { *m = WhoAmIRequest{} }
func (m *WhoAmIRequest) String() string { return proto1.CompactTextString(m) }
func (*WhoAmIRequest) ProtoMessage() {}
type WhoAmIResponse struct {
Username *string `protobuf:"bytes,1,opt,name=username" json:"username,omitempty"`
AuthMethod *string `protobuf:"bytes,2,opt,name=auth_method" json:"auth_method,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *WhoAmIResponse) Reset() { *m = WhoAmIResponse{} }
func (m *WhoAmIResponse) String() string { return proto1.CompactTextString(m) }
func (*WhoAmIResponse) ProtoMessage() {}
func (m *WhoAmIResponse) GetUsername() string {
if m != nil && m.Username != nil {
return *m.Username
}
return ""
}
func (m *WhoAmIResponse) GetAuthMethod() string {
if m != nil && m.AuthMethod != nil {
return *m.AuthMethod
}
return ""
}
func init() {
proto1.RegisterEnum("proto.TokenIdentifier_Kind", TokenIdentifier_Kind_name, TokenIdentifier_Kind_value)
}

197
vendor/github.com/pingcap/go-hbase/proto/Cell.pb.go generated vendored
View file

@ -1,197 +0,0 @@
// Code generated by protoc-gen-go.
// source: Cell.proto
// DO NOT EDIT!
package proto
import proto1 "github.com/golang/protobuf/proto"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto1.Marshal
var _ = math.Inf
// *
// The type of the key in a Cell
type CellType int32
const (
CellType_MINIMUM CellType = 0
CellType_PUT CellType = 4
CellType_DELETE CellType = 8
CellType_DELETE_COLUMN CellType = 12
CellType_DELETE_FAMILY CellType = 14
// MAXIMUM is used when searching; you look from maximum on down.
CellType_MAXIMUM CellType = 255
)
var CellType_name = map[int32]string{
0: "MINIMUM",
4: "PUT",
8: "DELETE",
12: "DELETE_COLUMN",
14: "DELETE_FAMILY",
255: "MAXIMUM",
}
var CellType_value = map[string]int32{
"MINIMUM": 0,
"PUT": 4,
"DELETE": 8,
"DELETE_COLUMN": 12,
"DELETE_FAMILY": 14,
"MAXIMUM": 255,
}
func (x CellType) Enum() *CellType {
p := new(CellType)
*p = x
return p
}
func (x CellType) String() string {
return proto1.EnumName(CellType_name, int32(x))
}
func (x *CellType) UnmarshalJSON(data []byte) error {
value, err := proto1.UnmarshalJSONEnum(CellType_value, data, "CellType")
if err != nil {
return err
}
*x = CellType(value)
return nil
}
// *
// Protocol buffer version of Cell.
type Cell struct {
Row []byte `protobuf:"bytes,1,opt,name=row" json:"row,omitempty"`
Family []byte `protobuf:"bytes,2,opt,name=family" json:"family,omitempty"`
Qualifier []byte `protobuf:"bytes,3,opt,name=qualifier" json:"qualifier,omitempty"`
Timestamp *uint64 `protobuf:"varint,4,opt,name=timestamp" json:"timestamp,omitempty"`
CellType *CellType `protobuf:"varint,5,opt,name=cell_type,enum=proto.CellType" json:"cell_type,omitempty"`
Value []byte `protobuf:"bytes,6,opt,name=value" json:"value,omitempty"`
Tags []byte `protobuf:"bytes,7,opt,name=tags" json:"tags,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Cell) Reset() { *m = Cell{} }
func (m *Cell) String() string { return proto1.CompactTextString(m) }
func (*Cell) ProtoMessage() {}
func (m *Cell) GetRow() []byte {
if m != nil {
return m.Row
}
return nil
}
func (m *Cell) GetFamily() []byte {
if m != nil {
return m.Family
}
return nil
}
func (m *Cell) GetQualifier() []byte {
if m != nil {
return m.Qualifier
}
return nil
}
func (m *Cell) GetTimestamp() uint64 {
if m != nil && m.Timestamp != nil {
return *m.Timestamp
}
return 0
}
func (m *Cell) GetCellType() CellType {
if m != nil && m.CellType != nil {
return *m.CellType
}
return CellType_MINIMUM
}
func (m *Cell) GetValue() []byte {
if m != nil {
return m.Value
}
return nil
}
func (m *Cell) GetTags() []byte {
if m != nil {
return m.Tags
}
return nil
}
// *
// Protocol buffer version of KeyValue.
// It doesn't have those transient parameters
type KeyValue struct {
Row []byte `protobuf:"bytes,1,req,name=row" json:"row,omitempty"`
Family []byte `protobuf:"bytes,2,req,name=family" json:"family,omitempty"`
Qualifier []byte `protobuf:"bytes,3,req,name=qualifier" json:"qualifier,omitempty"`
Timestamp *uint64 `protobuf:"varint,4,opt,name=timestamp" json:"timestamp,omitempty"`
KeyType *CellType `protobuf:"varint,5,opt,name=key_type,enum=proto.CellType" json:"key_type,omitempty"`
Value []byte `protobuf:"bytes,6,opt,name=value" json:"value,omitempty"`
Tags []byte `protobuf:"bytes,7,opt,name=tags" json:"tags,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *KeyValue) Reset() { *m = KeyValue{} }
func (m *KeyValue) String() string { return proto1.CompactTextString(m) }
func (*KeyValue) ProtoMessage() {}
func (m *KeyValue) GetRow() []byte {
if m != nil {
return m.Row
}
return nil
}
func (m *KeyValue) GetFamily() []byte {
if m != nil {
return m.Family
}
return nil
}
func (m *KeyValue) GetQualifier() []byte {
if m != nil {
return m.Qualifier
}
return nil
}
func (m *KeyValue) GetTimestamp() uint64 {
if m != nil && m.Timestamp != nil {
return *m.Timestamp
}
return 0
}
func (m *KeyValue) GetKeyType() CellType {
if m != nil && m.KeyType != nil {
return *m.KeyType
}
return CellType_MINIMUM
}
func (m *KeyValue) GetValue() []byte {
if m != nil {
return m.Value
}
return nil
}
func (m *KeyValue) GetTags() []byte {
if m != nil {
return m.Tags
}
return nil
}
func init() {
proto1.RegisterEnum("proto.CellType", CellType_name, CellType_value)
}

1411
vendor/github.com/pingcap/go-hbase/proto/Client.pb.go generated vendored
View file

File diff suppressed because it is too large Load diff

35
vendor/github.com/pingcap/go-hbase/proto/ClusterId.pb.go generated vendored
View file

@ -1,35 +0,0 @@
// Code generated by protoc-gen-go.
// source: ClusterId.proto
// DO NOT EDIT!
package proto
import proto1 "github.com/golang/protobuf/proto"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto1.Marshal
var _ = math.Inf
// *
// Content of the '/hbase/hbaseid', cluster id, znode.
// Also cluster of the ${HBASE_ROOTDIR}/hbase.id file.
type ClusterId struct {
// This is the cluster id, a uuid as a String
ClusterId *string `protobuf:"bytes,1,req,name=cluster_id" json:"cluster_id,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ClusterId) Reset() { *m = ClusterId{} }
func (m *ClusterId) String() string { return proto1.CompactTextString(m) }
func (*ClusterId) ProtoMessage() {}
func (m *ClusterId) GetClusterId() string {
if m != nil && m.ClusterId != nil {
return *m.ClusterId
}
return ""
}
func init() {
}

597
vendor/github.com/pingcap/go-hbase/proto/ClusterStatus.pb.go generated vendored
View file

@ -1,597 +0,0 @@
// Code generated by protoc-gen-go.
// source: ClusterStatus.proto
// DO NOT EDIT!
package proto
import proto1 "github.com/golang/protobuf/proto"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto1.Marshal
var _ = math.Inf
type RegionState_State int32
const (
RegionState_OFFLINE RegionState_State = 0
RegionState_PENDING_OPEN RegionState_State = 1
RegionState_OPENING RegionState_State = 2
RegionState_OPEN RegionState_State = 3
RegionState_PENDING_CLOSE RegionState_State = 4
RegionState_CLOSING RegionState_State = 5
RegionState_CLOSED RegionState_State = 6
RegionState_SPLITTING RegionState_State = 7
RegionState_SPLIT RegionState_State = 8
RegionState_FAILED_OPEN RegionState_State = 9
RegionState_FAILED_CLOSE RegionState_State = 10
RegionState_MERGING RegionState_State = 11
RegionState_MERGED RegionState_State = 12
RegionState_SPLITTING_NEW RegionState_State = 13
// region but hasn't be created yet, or master doesn't
// know it's already created
RegionState_MERGING_NEW RegionState_State = 14
)
var RegionState_State_name = map[int32]string{
0: "OFFLINE",
1: "PENDING_OPEN",
2: "OPENING",
3: "OPEN",
4: "PENDING_CLOSE",
5: "CLOSING",
6: "CLOSED",
7: "SPLITTING",
8: "SPLIT",
9: "FAILED_OPEN",
10: "FAILED_CLOSE",
11: "MERGING",
12: "MERGED",
13: "SPLITTING_NEW",
14: "MERGING_NEW",
}
var RegionState_State_value = map[string]int32{
"OFFLINE": 0,
"PENDING_OPEN": 1,
"OPENING": 2,
"OPEN": 3,
"PENDING_CLOSE": 4,
"CLOSING": 5,
"CLOSED": 6,
"SPLITTING": 7,
"SPLIT": 8,
"FAILED_OPEN": 9,
"FAILED_CLOSE": 10,
"MERGING": 11,
"MERGED": 12,
"SPLITTING_NEW": 13,
"MERGING_NEW": 14,
}
func (x RegionState_State) Enum() *RegionState_State {
p := new(RegionState_State)
*p = x
return p
}
func (x RegionState_State) String() string {
return proto1.EnumName(RegionState_State_name, int32(x))
}
func (x *RegionState_State) UnmarshalJSON(data []byte) error {
value, err := proto1.UnmarshalJSONEnum(RegionState_State_value, data, "RegionState_State")
if err != nil {
return err
}
*x = RegionState_State(value)
return nil
}
type RegionState struct {
RegionInfo *RegionInfo `protobuf:"bytes,1,req,name=region_info" json:"region_info,omitempty"`
State *RegionState_State `protobuf:"varint,2,req,name=state,enum=proto.RegionState_State" json:"state,omitempty"`
Stamp *uint64 `protobuf:"varint,3,opt,name=stamp" json:"stamp,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *RegionState) Reset() { *m = RegionState{} }
func (m *RegionState) String() string { return proto1.CompactTextString(m) }
func (*RegionState) ProtoMessage() {}
func (m *RegionState) GetRegionInfo() *RegionInfo {
if m != nil {
return m.RegionInfo
}
return nil
}
func (m *RegionState) GetState() RegionState_State {
if m != nil && m.State != nil {
return *m.State
}
return RegionState_OFFLINE
}
func (m *RegionState) GetStamp() uint64 {
if m != nil && m.Stamp != nil {
return *m.Stamp
}
return 0
}
type RegionInTransition struct {
Spec *RegionSpecifier `protobuf:"bytes,1,req,name=spec" json:"spec,omitempty"`
RegionState *RegionState `protobuf:"bytes,2,req,name=region_state" json:"region_state,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *RegionInTransition) Reset() { *m = RegionInTransition{} }
func (m *RegionInTransition) String() string { return proto1.CompactTextString(m) }
func (*RegionInTransition) ProtoMessage() {}
func (m *RegionInTransition) GetSpec() *RegionSpecifier {
if m != nil {
return m.Spec
}
return nil
}
func (m *RegionInTransition) GetRegionState() *RegionState {
if m != nil {
return m.RegionState
}
return nil
}
type RegionLoad struct {
// * the region specifier
RegionSpecifier *RegionSpecifier `protobuf:"bytes,1,req,name=region_specifier" json:"region_specifier,omitempty"`
// * the number of stores for the region
Stores *uint32 `protobuf:"varint,2,opt,name=stores" json:"stores,omitempty"`
// * the number of storefiles for the region
Storefiles *uint32 `protobuf:"varint,3,opt,name=storefiles" json:"storefiles,omitempty"`
// * the total size of the store files for the region, uncompressed, in MB
StoreUncompressedSize_MB *uint32 `protobuf:"varint,4,opt,name=store_uncompressed_size_MB" json:"store_uncompressed_size_MB,omitempty"`
// * the current total size of the store files for the region, in MB
StorefileSize_MB *uint32 `protobuf:"varint,5,opt,name=storefile_size_MB" json:"storefile_size_MB,omitempty"`
// * the current size of the memstore for the region, in MB
MemstoreSize_MB *uint32 `protobuf:"varint,6,opt,name=memstore_size_MB" json:"memstore_size_MB,omitempty"`
// *
// The current total size of root-level store file indexes for the region,
// in MB. The same as {@link #rootIndexSizeKB} but in MB.
StorefileIndexSize_MB *uint32 `protobuf:"varint,7,opt,name=storefile_index_size_MB" json:"storefile_index_size_MB,omitempty"`
// * the current total read requests made to region
ReadRequestsCount *uint64 `protobuf:"varint,8,opt,name=read_requests_count" json:"read_requests_count,omitempty"`
// * the current total write requests made to region
WriteRequestsCount *uint64 `protobuf:"varint,9,opt,name=write_requests_count" json:"write_requests_count,omitempty"`
// * the total compacting key values in currently running compaction
TotalCompacting_KVs *uint64 `protobuf:"varint,10,opt,name=total_compacting_KVs" json:"total_compacting_KVs,omitempty"`
// * the completed count of key values in currently running compaction
CurrentCompacted_KVs *uint64 `protobuf:"varint,11,opt,name=current_compacted_KVs" json:"current_compacted_KVs,omitempty"`
// * The current total size of root-level indexes for the region, in KB.
RootIndexSize_KB *uint32 `protobuf:"varint,12,opt,name=root_index_size_KB" json:"root_index_size_KB,omitempty"`
// * The total size of all index blocks, not just the root level, in KB.
TotalStaticIndexSize_KB *uint32 `protobuf:"varint,13,opt,name=total_static_index_size_KB" json:"total_static_index_size_KB,omitempty"`
// *
// The total size of all Bloom filter blocks, not just loaded into the
// block cache, in KB.
TotalStaticBloomSize_KB *uint32 `protobuf:"varint,14,opt,name=total_static_bloom_size_KB" json:"total_static_bloom_size_KB,omitempty"`
// * the most recent sequence Id from cache flush
CompleteSequenceId *uint64 `protobuf:"varint,15,opt,name=complete_sequence_id" json:"complete_sequence_id,omitempty"`
// * The current data locality for region in the regionserver
DataLocality *float32 `protobuf:"fixed32,16,opt,name=data_locality" json:"data_locality,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *RegionLoad) Reset() { *m = RegionLoad{} }
func (m *RegionLoad) String() string { return proto1.CompactTextString(m) }
func (*RegionLoad) ProtoMessage() {}
func (m *RegionLoad) GetRegionSpecifier() *RegionSpecifier {
if m != nil {
return m.RegionSpecifier
}
return nil
}
func (m *RegionLoad) GetStores() uint32 {
if m != nil && m.Stores != nil {
return *m.Stores
}
return 0
}
func (m *RegionLoad) GetStorefiles() uint32 {
if m != nil && m.Storefiles != nil {
return *m.Storefiles
}
return 0
}
func (m *RegionLoad) GetStoreUncompressedSize_MB() uint32 {
if m != nil && m.StoreUncompressedSize_MB != nil {
return *m.StoreUncompressedSize_MB
}
return 0
}
func (m *RegionLoad) GetStorefileSize_MB() uint32 {
if m != nil && m.StorefileSize_MB != nil {
return *m.StorefileSize_MB
}
return 0
}
func (m *RegionLoad) GetMemstoreSize_MB() uint32 {
if m != nil && m.MemstoreSize_MB != nil {
return *m.MemstoreSize_MB
}
return 0
}
func (m *RegionLoad) GetStorefileIndexSize_MB() uint32 {
if m != nil && m.StorefileIndexSize_MB != nil {
return *m.StorefileIndexSize_MB
}
return 0
}
func (m *RegionLoad) GetReadRequestsCount() uint64 {
if m != nil && m.ReadRequestsCount != nil {
return *m.ReadRequestsCount
}
return 0
}
func (m *RegionLoad) GetWriteRequestsCount() uint64 {
if m != nil && m.WriteRequestsCount != nil {
return *m.WriteRequestsCount
}
return 0
}
func (m *RegionLoad) GetTotalCompacting_KVs() uint64 {
if m != nil && m.TotalCompacting_KVs != nil {
return *m.TotalCompacting_KVs
}
return 0
}
func (m *RegionLoad) GetCurrentCompacted_KVs() uint64 {
if m != nil && m.CurrentCompacted_KVs != nil {
return *m.CurrentCompacted_KVs
}
return 0
}
func (m *RegionLoad) GetRootIndexSize_KB() uint32 {
if m != nil && m.RootIndexSize_KB != nil {
return *m.RootIndexSize_KB
}
return 0
}
func (m *RegionLoad) GetTotalStaticIndexSize_KB() uint32 {
if m != nil && m.TotalStaticIndexSize_KB != nil {
return *m.TotalStaticIndexSize_KB
}
return 0
}
func (m *RegionLoad) GetTotalStaticBloomSize_KB() uint32 {
if m != nil && m.TotalStaticBloomSize_KB != nil {
return *m.TotalStaticBloomSize_KB
}
return 0
}
func (m *RegionLoad) GetCompleteSequenceId() uint64 {
if m != nil && m.CompleteSequenceId != nil {
return *m.CompleteSequenceId
}
return 0
}
func (m *RegionLoad) GetDataLocality() float32 {
if m != nil && m.DataLocality != nil {
return *m.DataLocality
}
return 0
}
type ReplicationLoadSink struct {
AgeOfLastAppliedOp *uint64 `protobuf:"varint,1,req,name=ageOfLastAppliedOp" json:"ageOfLastAppliedOp,omitempty"`
TimeStampsOfLastAppliedOp *uint64 `protobuf:"varint,2,req,name=timeStampsOfLastAppliedOp" json:"timeStampsOfLastAppliedOp,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ReplicationLoadSink) Reset() { *m = ReplicationLoadSink{} }
func (m *ReplicationLoadSink) String() string { return proto1.CompactTextString(m) }
func (*ReplicationLoadSink) ProtoMessage() {}
func (m *ReplicationLoadSink) GetAgeOfLastAppliedOp() uint64 {
if m != nil && m.AgeOfLastAppliedOp != nil {
return *m.AgeOfLastAppliedOp
}
return 0
}
func (m *ReplicationLoadSink) GetTimeStampsOfLastAppliedOp() uint64 {
if m != nil && m.TimeStampsOfLastAppliedOp != nil {
return *m.TimeStampsOfLastAppliedOp
}
return 0
}
type ReplicationLoadSource struct {
PeerID *string `protobuf:"bytes,1,req,name=peerID" json:"peerID,omitempty"`
AgeOfLastShippedOp *uint64 `protobuf:"varint,2,req,name=ageOfLastShippedOp" json:"ageOfLastShippedOp,omitempty"`
SizeOfLogQueue *uint32 `protobuf:"varint,3,req,name=sizeOfLogQueue" json:"sizeOfLogQueue,omitempty"`
TimeStampOfLastShippedOp *uint64 `protobuf:"varint,4,req,name=timeStampOfLastShippedOp" json:"timeStampOfLastShippedOp,omitempty"`
ReplicationLag *uint64 `protobuf:"varint,5,req,name=replicationLag" json:"replicationLag,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ReplicationLoadSource) Reset() { *m = ReplicationLoadSource{} }
func (m *ReplicationLoadSource) String() string { return proto1.CompactTextString(m) }
func (*ReplicationLoadSource) ProtoMessage() {}
func (m *ReplicationLoadSource) GetPeerID() string {
if m != nil && m.PeerID != nil {
return *m.PeerID
}
return ""
}
func (m *ReplicationLoadSource) GetAgeOfLastShippedOp() uint64 {
if m != nil && m.AgeOfLastShippedOp != nil {
return *m.AgeOfLastShippedOp
}
return 0
}
func (m *ReplicationLoadSource) GetSizeOfLogQueue() uint32 {
if m != nil && m.SizeOfLogQueue != nil {
return *m.SizeOfLogQueue
}
return 0
}
func (m *ReplicationLoadSource) GetTimeStampOfLastShippedOp() uint64 {
if m != nil && m.TimeStampOfLastShippedOp != nil {
return *m.TimeStampOfLastShippedOp
}
return 0
}
func (m *ReplicationLoadSource) GetReplicationLag() uint64 {
if m != nil && m.ReplicationLag != nil {
return *m.ReplicationLag
}
return 0
}
type ServerLoad struct {
// * Number of requests since last report.
NumberOfRequests *uint32 `protobuf:"varint,1,opt,name=number_of_requests" json:"number_of_requests,omitempty"`
// * Total Number of requests from the start of the region server.
TotalNumberOfRequests *uint32 `protobuf:"varint,2,opt,name=total_number_of_requests" json:"total_number_of_requests,omitempty"`
// * the amount of used heap, in MB.
UsedHeap_MB *uint32 `protobuf:"varint,3,opt,name=used_heap_MB" json:"used_heap_MB,omitempty"`
// * the maximum allowable size of the heap, in MB.
MaxHeap_MB *uint32 `protobuf:"varint,4,opt,name=max_heap_MB" json:"max_heap_MB,omitempty"`
// * Information on the load of individual regions.
RegionLoads []*RegionLoad `protobuf:"bytes,5,rep,name=region_loads" json:"region_loads,omitempty"`
// *
// Regionserver-level coprocessors, e.g., WALObserver implementations.
// Region-level coprocessors, on the other hand, are stored inside RegionLoad
// objects.
Coprocessors []*Coprocessor `protobuf:"bytes,6,rep,name=coprocessors" json:"coprocessors,omitempty"`
// *
// Time when incremental (non-total) counts began being calculated (e.g. number_of_requests)
// time is measured as the difference, measured in milliseconds, between the current time
// and midnight, January 1, 1970 UTC.
ReportStartTime *uint64 `protobuf:"varint,7,opt,name=report_start_time" json:"report_start_time,omitempty"`
// *
// Time when report was generated.
// time is measured as the difference, measured in milliseconds, between the current time
// and midnight, January 1, 1970 UTC.
ReportEndTime *uint64 `protobuf:"varint,8,opt,name=report_end_time" json:"report_end_time,omitempty"`
// *
// The port number that this region server is hosing an info server on.
InfoServerPort *uint32 `protobuf:"varint,9,opt,name=info_server_port" json:"info_server_port,omitempty"`
// *
// The replicationLoadSource for the replication Source status of this region server.
ReplLoadSource []*ReplicationLoadSource `protobuf:"bytes,10,rep,name=replLoadSource" json:"replLoadSource,omitempty"`
// *
// The replicationLoadSink for the replication Sink status of this region server.
ReplLoadSink *ReplicationLoadSink `protobuf:"bytes,11,opt,name=replLoadSink" json:"replLoadSink,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ServerLoad) Reset() { *m = ServerLoad{} }
func (m *ServerLoad) String() string { return proto1.CompactTextString(m) }
func (*ServerLoad) ProtoMessage() {}
func (m *ServerLoad) GetNumberOfRequests() uint32 {
if m != nil && m.NumberOfRequests != nil {
return *m.NumberOfRequests
}
return 0
}
func (m *ServerLoad) GetTotalNumberOfRequests() uint32 {
if m != nil && m.TotalNumberOfRequests != nil {
return *m.TotalNumberOfRequests
}
return 0
}
func (m *ServerLoad) GetUsedHeap_MB() uint32 {
if m != nil && m.UsedHeap_MB != nil {
return *m.UsedHeap_MB
}
return 0
}
func (m *ServerLoad) GetMaxHeap_MB() uint32 {
if m != nil && m.MaxHeap_MB != nil {
return *m.MaxHeap_MB
}
return 0
}
func (m *ServerLoad) GetRegionLoads() []*RegionLoad {
if m != nil {
return m.RegionLoads
}
return nil
}
func (m *ServerLoad) GetCoprocessors() []*Coprocessor {
if m != nil {
return m.Coprocessors
}
return nil
}
func (m *ServerLoad) GetReportStartTime() uint64 {
if m != nil && m.ReportStartTime != nil {
return *m.ReportStartTime
}
return 0
}
func (m *ServerLoad) GetReportEndTime() uint64 {
if m != nil && m.ReportEndTime != nil {
return *m.ReportEndTime
}
return 0
}
func (m *ServerLoad) GetInfoServerPort() uint32 {
if m != nil && m.InfoServerPort != nil {
return *m.InfoServerPort
}
return 0
}
func (m *ServerLoad) GetReplLoadSource() []*ReplicationLoadSource {
if m != nil {
return m.ReplLoadSource
}
return nil
}
func (m *ServerLoad) GetReplLoadSink() *ReplicationLoadSink {
if m != nil {
return m.ReplLoadSink
}
return nil
}
type LiveServerInfo struct {
Server *ServerName `protobuf:"bytes,1,req,name=server" json:"server,omitempty"`
ServerLoad *ServerLoad `protobuf:"bytes,2,req,name=server_load" json:"server_load,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *LiveServerInfo) Reset() { *m = LiveServerInfo{} }
func (m *LiveServerInfo) String() string { return proto1.CompactTextString(m) }
func (*LiveServerInfo) ProtoMessage() {}
func (m *LiveServerInfo) GetServer() *ServerName {
if m != nil {
return m.Server
}
return nil
}
func (m *LiveServerInfo) GetServerLoad() *ServerLoad {
if m != nil {
return m.ServerLoad
}
return nil
}
type ClusterStatus struct {
HbaseVersion *HBaseVersionFileContent `protobuf:"bytes,1,opt,name=hbase_version" json:"hbase_version,omitempty"`
LiveServers []*LiveServerInfo `protobuf:"bytes,2,rep,name=live_servers" json:"live_servers,omitempty"`
DeadServers []*ServerName `protobuf:"bytes,3,rep,name=dead_servers" json:"dead_servers,omitempty"`
RegionsInTransition []*RegionInTransition `protobuf:"bytes,4,rep,name=regions_in_transition" json:"regions_in_transition,omitempty"`
ClusterId *ClusterId `protobuf:"bytes,5,opt,name=cluster_id" json:"cluster_id,omitempty"`
MasterCoprocessors []*Coprocessor `protobuf:"bytes,6,rep,name=master_coprocessors" json:"master_coprocessors,omitempty"`
Master *ServerName `protobuf:"bytes,7,opt,name=master" json:"master,omitempty"`
BackupMasters []*ServerName `protobuf:"bytes,8,rep,name=backup_masters" json:"backup_masters,omitempty"`
BalancerOn *bool `protobuf:"varint,9,opt,name=balancer_on" json:"balancer_on,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ClusterStatus) Reset() { *m = ClusterStatus{} }
func (m *ClusterStatus) String() string { return proto1.CompactTextString(m) }
func (*ClusterStatus) ProtoMessage() {}
func (m *ClusterStatus) GetHbaseVersion() *HBaseVersionFileContent {
if m != nil {
return m.HbaseVersion
}
return nil
}
func (m *ClusterStatus) GetLiveServers() []*LiveServerInfo {
if m != nil {
return m.LiveServers
}
return nil
}
func (m *ClusterStatus) GetDeadServers() []*ServerName {
if m != nil {
return m.DeadServers
}
return nil
}
func (m *ClusterStatus) GetRegionsInTransition() []*RegionInTransition {
if m != nil {
return m.RegionsInTransition
}
return nil
}
func (m *ClusterStatus) GetClusterId() *ClusterId {
if m != nil {
return m.ClusterId
}
return nil
}
func (m *ClusterStatus) GetMasterCoprocessors() []*Coprocessor {
if m != nil {
return m.MasterCoprocessors
}
return nil
}
func (m *ClusterStatus) GetMaster() *ServerName {
if m != nil {
return m.Master
}
return nil
}
func (m *ClusterStatus) GetBackupMasters() []*ServerName {
if m != nil {
return m.BackupMasters
}
return nil
}
func (m *ClusterStatus) GetBalancerOn() bool {
if m != nil && m.BalancerOn != nil {
return *m.BalancerOn
}
return false
}
func init() {
proto1.RegisterEnum("proto.RegionState_State", RegionState_State_name, RegionState_State_value)
}

228
vendor/github.com/pingcap/go-hbase/proto/Comparator.pb.go generated vendored
View file

@ -1,228 +0,0 @@
// Code generated by protoc-gen-go.
// source: Comparator.proto
// DO NOT EDIT!
package proto
import proto1 "github.com/golang/protobuf/proto"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto1.Marshal
var _ = math.Inf
type BitComparator_BitwiseOp int32
const (
BitComparator_AND BitComparator_BitwiseOp = 1
BitComparator_OR BitComparator_BitwiseOp = 2
BitComparator_XOR BitComparator_BitwiseOp = 3
)
var BitComparator_BitwiseOp_name = map[int32]string{
1: "AND",
2: "OR",
3: "XOR",
}
var BitComparator_BitwiseOp_value = map[string]int32{
"AND": 1,
"OR": 2,
"XOR": 3,
}
func (x BitComparator_BitwiseOp) Enum() *BitComparator_BitwiseOp {
p := new(BitComparator_BitwiseOp)
*p = x
return p
}
func (x BitComparator_BitwiseOp) String() string {
return proto1.EnumName(BitComparator_BitwiseOp_name, int32(x))
}
func (x *BitComparator_BitwiseOp) UnmarshalJSON(data []byte) error {
value, err := proto1.UnmarshalJSONEnum(BitComparator_BitwiseOp_value, data, "BitComparator_BitwiseOp")
if err != nil {
return err
}
*x = BitComparator_BitwiseOp(value)
return nil
}
type Comparator struct {
Name *string `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
SerializedComparator []byte `protobuf:"bytes,2,opt,name=serialized_comparator" json:"serialized_comparator,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Comparator) Reset() { *m = Comparator{} }
func (m *Comparator) String() string { return proto1.CompactTextString(m) }
func (*Comparator) ProtoMessage() {}
func (m *Comparator) GetName() string {
if m != nil && m.Name != nil {
return *m.Name
}
return ""
}
func (m *Comparator) GetSerializedComparator() []byte {
if m != nil {
return m.SerializedComparator
}
return nil
}
type ByteArrayComparable struct {
Value []byte `protobuf:"bytes,1,opt,name=value" json:"value,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ByteArrayComparable) Reset() { *m = ByteArrayComparable{} }
func (m *ByteArrayComparable) String() string { return proto1.CompactTextString(m) }
func (*ByteArrayComparable) ProtoMessage() {}
func (m *ByteArrayComparable) GetValue() []byte {
if m != nil {
return m.Value
}
return nil
}
type BinaryComparator struct {
Comparable *ByteArrayComparable `protobuf:"bytes,1,req,name=comparable" json:"comparable,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *BinaryComparator) Reset() { *m = BinaryComparator{} }
func (m *BinaryComparator) String() string { return proto1.CompactTextString(m) }
func (*BinaryComparator) ProtoMessage() {}
func (m *BinaryComparator) GetComparable() *ByteArrayComparable {
if m != nil {
return m.Comparable
}
return nil
}
type LongComparator struct {
Comparable *ByteArrayComparable `protobuf:"bytes,1,req,name=comparable" json:"comparable,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *LongComparator) Reset() { *m = LongComparator{} }
func (m *LongComparator) String() string { return proto1.CompactTextString(m) }
func (*LongComparator) ProtoMessage() {}
func (m *LongComparator) GetComparable() *ByteArrayComparable {
if m != nil {
return m.Comparable
}
return nil
}
type BinaryPrefixComparator struct {
Comparable *ByteArrayComparable `protobuf:"bytes,1,req,name=comparable" json:"comparable,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *BinaryPrefixComparator) Reset() { *m = BinaryPrefixComparator{} }
func (m *BinaryPrefixComparator) String() string { return proto1.CompactTextString(m) }
func (*BinaryPrefixComparator) ProtoMessage() {}
func (m *BinaryPrefixComparator) GetComparable() *ByteArrayComparable {
if m != nil {
return m.Comparable
}
return nil
}
type BitComparator struct {
Comparable *ByteArrayComparable `protobuf:"bytes,1,req,name=comparable" json:"comparable,omitempty"`
BitwiseOp *BitComparator_BitwiseOp `protobuf:"varint,2,req,name=bitwise_op,enum=proto.BitComparator_BitwiseOp" json:"bitwise_op,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *BitComparator) Reset() { *m = BitComparator{} }
func (m *BitComparator) String() string { return proto1.CompactTextString(m) }
func (*BitComparator) ProtoMessage() {}
func (m *BitComparator) GetComparable() *ByteArrayComparable {
if m != nil {
return m.Comparable
}
return nil
}
func (m *BitComparator) GetBitwiseOp() BitComparator_BitwiseOp {
if m != nil && m.BitwiseOp != nil {
return *m.BitwiseOp
}
return BitComparator_AND
}
type NullComparator struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *NullComparator) Reset() { *m = NullComparator{} }
func (m *NullComparator) String() string { return proto1.CompactTextString(m) }
func (*NullComparator) ProtoMessage() {}
type RegexStringComparator struct {
Pattern *string `protobuf:"bytes,1,req,name=pattern" json:"pattern,omitempty"`
PatternFlags *int32 `protobuf:"varint,2,req,name=pattern_flags" json:"pattern_flags,omitempty"`
Charset *string `protobuf:"bytes,3,req,name=charset" json:"charset,omitempty"`
Engine *string `protobuf:"bytes,4,opt,name=engine" json:"engine,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *RegexStringComparator) Reset() { *m = RegexStringComparator{} }
func (m *RegexStringComparator) String() string { return proto1.CompactTextString(m) }
func (*RegexStringComparator) ProtoMessage() {}
func (m *RegexStringComparator) GetPattern() string {
if m != nil && m.Pattern != nil {
return *m.Pattern
}
return ""
}
func (m *RegexStringComparator) GetPatternFlags() int32 {
if m != nil && m.PatternFlags != nil {
return *m.PatternFlags
}
return 0
}
func (m *RegexStringComparator) GetCharset() string {
if m != nil && m.Charset != nil {
return *m.Charset
}
return ""
}
func (m *RegexStringComparator) GetEngine() string {
if m != nil && m.Engine != nil {
return *m.Engine
}
return ""
}
type SubstringComparator struct {
Substr *string `protobuf:"bytes,1,req,name=substr" json:"substr,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *SubstringComparator) Reset() { *m = SubstringComparator{} }
func (m *SubstringComparator) String() string { return proto1.CompactTextString(m) }
func (*SubstringComparator) ProtoMessage() {}
func (m *SubstringComparator) GetSubstr() string {
if m != nil && m.Substr != nil {
return *m.Substr
}
return ""
}
func init() {
proto1.RegisterEnum("proto.BitComparator_BitwiseOp", BitComparator_BitwiseOp_name, BitComparator_BitwiseOp_value)
}

63
vendor/github.com/pingcap/go-hbase/proto/Encryption.pb.go generated vendored
View file

@ -1,63 +0,0 @@
// Code generated by protoc-gen-go.
// source: Encryption.proto
// DO NOT EDIT!
package proto
import proto1 "github.com/golang/protobuf/proto"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto1.Marshal
var _ = math.Inf
type WrappedKey struct {
Algorithm *string `protobuf:"bytes,1,req,name=algorithm" json:"algorithm,omitempty"`
Length *uint32 `protobuf:"varint,2,req,name=length" json:"length,omitempty"`
Data []byte `protobuf:"bytes,3,req,name=data" json:"data,omitempty"`
Iv []byte `protobuf:"bytes,4,opt,name=iv" json:"iv,omitempty"`
Hash []byte `protobuf:"bytes,5,opt,name=hash" json:"hash,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *WrappedKey) Reset() { *m = WrappedKey{} }
func (m *WrappedKey) String() string { return proto1.CompactTextString(m) }
func (*WrappedKey) ProtoMessage() {}
func (m *WrappedKey) GetAlgorithm() string {
if m != nil && m.Algorithm != nil {
return *m.Algorithm
}
return ""
}
func (m *WrappedKey) GetLength() uint32 {
if m != nil && m.Length != nil {
return *m.Length
}
return 0
}
func (m *WrappedKey) GetData() []byte {
if m != nil {
return m.Data
}
return nil
}
func (m *WrappedKey) GetIv() []byte {
if m != nil {
return m.Iv
}
return nil
}
func (m *WrappedKey) GetHash() []byte {
if m != nil {
return m.Hash
}
return nil
}
func init() {
}

130
vendor/github.com/pingcap/go-hbase/proto/ErrorHandling.pb.go generated vendored
View file

@ -1,130 +0,0 @@
// Code generated by protoc-gen-go.
// source: ErrorHandling.proto
// DO NOT EDIT!
package proto
import proto1 "github.com/golang/protobuf/proto"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto1.Marshal
var _ = math.Inf
// *
// Protobuf version of a java.lang.StackTraceElement
// so we can serialize exceptions.
type StackTraceElementMessage struct {
DeclaringClass *string `protobuf:"bytes,1,opt,name=declaring_class" json:"declaring_class,omitempty"`
MethodName *string `protobuf:"bytes,2,opt,name=method_name" json:"method_name,omitempty"`
FileName *string `protobuf:"bytes,3,opt,name=file_name" json:"file_name,omitempty"`
LineNumber *int32 `protobuf:"varint,4,opt,name=line_number" json:"line_number,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *StackTraceElementMessage) Reset() { *m = StackTraceElementMessage{} }
func (m *StackTraceElementMessage) String() string { return proto1.CompactTextString(m) }
func (*StackTraceElementMessage) ProtoMessage() {}
func (m *StackTraceElementMessage) GetDeclaringClass() string {
if m != nil && m.DeclaringClass != nil {
return *m.DeclaringClass
}
return ""
}
func (m *StackTraceElementMessage) GetMethodName() string {
if m != nil && m.MethodName != nil {
return *m.MethodName
}
return ""
}
func (m *StackTraceElementMessage) GetFileName() string {
if m != nil && m.FileName != nil {
return *m.FileName
}
return ""
}
func (m *StackTraceElementMessage) GetLineNumber() int32 {
if m != nil && m.LineNumber != nil {
return *m.LineNumber
}
return 0
}
// *
// Cause of a remote failure for a generic exception. Contains
// all the information for a generic exception as well as
// optional info about the error for generic info passing
// (which should be another protobuffed class).
type GenericExceptionMessage struct {
ClassName *string `protobuf:"bytes,1,opt,name=class_name" json:"class_name,omitempty"`
Message *string `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"`
ErrorInfo []byte `protobuf:"bytes,3,opt,name=error_info" json:"error_info,omitempty"`
Trace []*StackTraceElementMessage `protobuf:"bytes,4,rep,name=trace" json:"trace,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GenericExceptionMessage) Reset() { *m = GenericExceptionMessage{} }
func (m *GenericExceptionMessage) String() string { return proto1.CompactTextString(m) }
func (*GenericExceptionMessage) ProtoMessage() {}
func (m *GenericExceptionMessage) GetClassName() string {
if m != nil && m.ClassName != nil {
return *m.ClassName
}
return ""
}
func (m *GenericExceptionMessage) GetMessage() string {
if m != nil && m.Message != nil {
return *m.Message
}
return ""
}
func (m *GenericExceptionMessage) GetErrorInfo() []byte {
if m != nil {
return m.ErrorInfo
}
return nil
}
func (m *GenericExceptionMessage) GetTrace() []*StackTraceElementMessage {
if m != nil {
return m.Trace
}
return nil
}
// *
// Exception sent across the wire when a remote task needs
// to notify other tasks that it failed and why
type ForeignExceptionMessage struct {
Source *string `protobuf:"bytes,1,opt,name=source" json:"source,omitempty"`
GenericException *GenericExceptionMessage `protobuf:"bytes,2,opt,name=generic_exception" json:"generic_exception,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ForeignExceptionMessage) Reset() { *m = ForeignExceptionMessage{} }
func (m *ForeignExceptionMessage) String() string { return proto1.CompactTextString(m) }
func (*ForeignExceptionMessage) ProtoMessage() {}
func (m *ForeignExceptionMessage) GetSource() string {
if m != nil && m.Source != nil {
return *m.Source
}
return ""
}
func (m *ForeignExceptionMessage) GetGenericException() *GenericExceptionMessage {
if m != nil {
return m.GenericException
}
return nil
}
func init() {
}

93
vendor/github.com/pingcap/go-hbase/proto/FS.pb.go generated vendored
View file

@ -1,93 +0,0 @@
// Code generated by protoc-gen-go.
// source: FS.proto
// DO NOT EDIT!
package proto
import proto1 "github.com/golang/protobuf/proto"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto1.Marshal
var _ = math.Inf
type Reference_Range int32
const (
Reference_TOP Reference_Range = 0
Reference_BOTTOM Reference_Range = 1
)
var Reference_Range_name = map[int32]string{
0: "TOP",
1: "BOTTOM",
}
var Reference_Range_value = map[string]int32{
"TOP": 0,
"BOTTOM": 1,
}
func (x Reference_Range) Enum() *Reference_Range {
p := new(Reference_Range)
*p = x
return p
}
func (x Reference_Range) String() string {
return proto1.EnumName(Reference_Range_name, int32(x))
}
func (x *Reference_Range) UnmarshalJSON(data []byte) error {
value, err := proto1.UnmarshalJSONEnum(Reference_Range_value, data, "Reference_Range")
if err != nil {
return err
}
*x = Reference_Range(value)
return nil
}
// *
// The ${HBASE_ROOTDIR}/hbase.version file content
type HBaseVersionFileContent struct {
Version *string `protobuf:"bytes,1,req,name=version" json:"version,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *HBaseVersionFileContent) Reset() { *m = HBaseVersionFileContent{} }
func (m *HBaseVersionFileContent) String() string { return proto1.CompactTextString(m) }
func (*HBaseVersionFileContent) ProtoMessage() {}
func (m *HBaseVersionFileContent) GetVersion() string {
if m != nil && m.Version != nil {
return *m.Version
}
return ""
}
// *
// Reference file content used when we split an hfile under a region.
type Reference struct {
Splitkey []byte `protobuf:"bytes,1,req,name=splitkey" json:"splitkey,omitempty"`
Range *Reference_Range `protobuf:"varint,2,req,name=range,enum=proto.Reference_Range" json:"range,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Reference) Reset() { *m = Reference{} }
func (m *Reference) String() string { return proto1.CompactTextString(m) }
func (*Reference) ProtoMessage() {}
func (m *Reference) GetSplitkey() []byte {
if m != nil {
return m.Splitkey
}
return nil
}
func (m *Reference) GetRange() Reference_Range {
if m != nil && m.Range != nil {
return *m.Range
}
return Reference_TOP
}
func init() {
proto1.RegisterEnum("proto.Reference_Range", Reference_Range_name, Reference_Range_value)
}

609
vendor/github.com/pingcap/go-hbase/proto/Filter.pb.go generated vendored
View file

@ -1,609 +0,0 @@
// Code generated by protoc-gen-go.
// source: Filter.proto
// DO NOT EDIT!
package proto
import proto1 "github.com/golang/protobuf/proto"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto1.Marshal
var _ = math.Inf
type FilterList_Operator int32
const (
FilterList_MUST_PASS_ALL FilterList_Operator = 1
FilterList_MUST_PASS_ONE FilterList_Operator = 2
)
var FilterList_Operator_name = map[int32]string{
1: "MUST_PASS_ALL",
2: "MUST_PASS_ONE",
}
var FilterList_Operator_value = map[string]int32{
"MUST_PASS_ALL": 1,
"MUST_PASS_ONE": 2,
}
func (x FilterList_Operator) Enum() *FilterList_Operator {
p := new(FilterList_Operator)
*p = x
return p
}
func (x FilterList_Operator) String() string {
return proto1.EnumName(FilterList_Operator_name, int32(x))
}
func (x *FilterList_Operator) UnmarshalJSON(data []byte) error {
value, err := proto1.UnmarshalJSONEnum(FilterList_Operator_value, data, "FilterList_Operator")
if err != nil {
return err
}
*x = FilterList_Operator(value)
return nil
}
type Filter struct {
Name *string `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
SerializedFilter []byte `protobuf:"bytes,2,opt,name=serialized_filter" json:"serialized_filter,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Filter) Reset() { *m = Filter{} }
func (m *Filter) String() string { return proto1.CompactTextString(m) }
func (*Filter) ProtoMessage() {}
func (m *Filter) GetName() string {
if m != nil && m.Name != nil {
return *m.Name
}
return ""
}
func (m *Filter) GetSerializedFilter() []byte {
if m != nil {
return m.SerializedFilter
}
return nil
}
type ColumnCountGetFilter struct {
Limit *int32 `protobuf:"varint,1,req,name=limit" json:"limit,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ColumnCountGetFilter) Reset() { *m = ColumnCountGetFilter{} }
func (m *ColumnCountGetFilter) String() string { return proto1.CompactTextString(m) }
func (*ColumnCountGetFilter) ProtoMessage() {}
func (m *ColumnCountGetFilter) GetLimit() int32 {
if m != nil && m.Limit != nil {
return *m.Limit
}
return 0
}
type ColumnPaginationFilter struct {
Limit *int32 `protobuf:"varint,1,req,name=limit" json:"limit,omitempty"`
Offset *int32 `protobuf:"varint,2,opt,name=offset" json:"offset,omitempty"`
ColumnOffset []byte `protobuf:"bytes,3,opt,name=column_offset" json:"column_offset,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ColumnPaginationFilter) Reset() { *m = ColumnPaginationFilter{} }
func (m *ColumnPaginationFilter) String() string { return proto1.CompactTextString(m) }
func (*ColumnPaginationFilter) ProtoMessage() {}
func (m *ColumnPaginationFilter) GetLimit() int32 {
if m != nil && m.Limit != nil {
return *m.Limit
}
return 0
}
func (m *ColumnPaginationFilter) GetOffset() int32 {
if m != nil && m.Offset != nil {
return *m.Offset
}
return 0
}
func (m *ColumnPaginationFilter) GetColumnOffset() []byte {
if m != nil {
return m.ColumnOffset
}
return nil
}
type ColumnPrefixFilter struct {
Prefix []byte `protobuf:"bytes,1,req,name=prefix" json:"prefix,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ColumnPrefixFilter) Reset() { *m = ColumnPrefixFilter{} }
func (m *ColumnPrefixFilter) String() string { return proto1.CompactTextString(m) }
func (*ColumnPrefixFilter) ProtoMessage() {}
func (m *ColumnPrefixFilter) GetPrefix() []byte {
if m != nil {
return m.Prefix
}
return nil
}
type ColumnRangeFilter struct {
MinColumn []byte `protobuf:"bytes,1,opt,name=min_column" json:"min_column,omitempty"`
MinColumnInclusive *bool `protobuf:"varint,2,opt,name=min_column_inclusive" json:"min_column_inclusive,omitempty"`
MaxColumn []byte `protobuf:"bytes,3,opt,name=max_column" json:"max_column,omitempty"`
MaxColumnInclusive *bool `protobuf:"varint,4,opt,name=max_column_inclusive" json:"max_column_inclusive,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ColumnRangeFilter) Reset() { *m = ColumnRangeFilter{} }
func (m *ColumnRangeFilter) String() string { return proto1.CompactTextString(m) }
func (*ColumnRangeFilter) ProtoMessage() {}
func (m *ColumnRangeFilter) GetMinColumn() []byte {
if m != nil {
return m.MinColumn
}
return nil
}
func (m *ColumnRangeFilter) GetMinColumnInclusive() bool {
if m != nil && m.MinColumnInclusive != nil {
return *m.MinColumnInclusive
}
return false
}
func (m *ColumnRangeFilter) GetMaxColumn() []byte {
if m != nil {
return m.MaxColumn
}
return nil
}
func (m *ColumnRangeFilter) GetMaxColumnInclusive() bool {
if m != nil && m.MaxColumnInclusive != nil {
return *m.MaxColumnInclusive
}
return false
}
type CompareFilter struct {
CompareOp *CompareType `protobuf:"varint,1,req,name=compare_op,enum=proto.CompareType" json:"compare_op,omitempty"`
Comparator *Comparator `protobuf:"bytes,2,opt,name=comparator" json:"comparator,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CompareFilter) Reset() { *m = CompareFilter{} }
func (m *CompareFilter) String() string { return proto1.CompactTextString(m) }
func (*CompareFilter) ProtoMessage() {}
func (m *CompareFilter) GetCompareOp() CompareType {
if m != nil && m.CompareOp != nil {
return *m.CompareOp
}
return CompareType_LESS
}
func (m *CompareFilter) GetComparator() *Comparator {
if m != nil {
return m.Comparator
}
return nil
}
type DependentColumnFilter struct {
CompareFilter *CompareFilter `protobuf:"bytes,1,req,name=compare_filter" json:"compare_filter,omitempty"`
ColumnFamily []byte `protobuf:"bytes,2,opt,name=column_family" json:"column_family,omitempty"`
ColumnQualifier []byte `protobuf:"bytes,3,opt,name=column_qualifier" json:"column_qualifier,omitempty"`
DropDependentColumn *bool `protobuf:"varint,4,opt,name=drop_dependent_column" json:"drop_dependent_column,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *DependentColumnFilter) Reset() { *m = DependentColumnFilter{} }
func (m *DependentColumnFilter) String() string { return proto1.CompactTextString(m) }
func (*DependentColumnFilter) ProtoMessage() {}
func (m *DependentColumnFilter) GetCompareFilter() *CompareFilter {
if m != nil {
return m.CompareFilter
}
return nil
}
func (m *DependentColumnFilter) GetColumnFamily() []byte {
if m != nil {
return m.ColumnFamily
}
return nil
}
func (m *DependentColumnFilter) GetColumnQualifier() []byte {
if m != nil {
return m.ColumnQualifier
}
return nil
}
func (m *DependentColumnFilter) GetDropDependentColumn() bool {
if m != nil && m.DropDependentColumn != nil {
return *m.DropDependentColumn
}
return false
}
type FamilyFilter struct {
CompareFilter *CompareFilter `protobuf:"bytes,1,req,name=compare_filter" json:"compare_filter,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *FamilyFilter) Reset() { *m = FamilyFilter{} }
func (m *FamilyFilter) String() string { return proto1.CompactTextString(m) }
func (*FamilyFilter) ProtoMessage() {}
func (m *FamilyFilter) GetCompareFilter() *CompareFilter {
if m != nil {
return m.CompareFilter
}
return nil
}
type FilterList struct {
Operator *FilterList_Operator `protobuf:"varint,1,req,name=operator,enum=proto.FilterList_Operator" json:"operator,omitempty"`
Filters []*Filter `protobuf:"bytes,2,rep,name=filters" json:"filters,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *FilterList) Reset() { *m = FilterList{} }
func (m *FilterList) String() string { return proto1.CompactTextString(m) }
func (*FilterList) ProtoMessage() {}
func (m *FilterList) GetOperator() FilterList_Operator {
if m != nil && m.Operator != nil {
return *m.Operator
}
return FilterList_MUST_PASS_ALL
}
func (m *FilterList) GetFilters() []*Filter {
if m != nil {
return m.Filters
}
return nil
}
type FilterWrapper struct {
Filter *Filter `protobuf:"bytes,1,req,name=filter" json:"filter,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *FilterWrapper) Reset() { *m = FilterWrapper{} }
func (m *FilterWrapper) String() string { return proto1.CompactTextString(m) }
func (*FilterWrapper) ProtoMessage() {}
func (m *FilterWrapper) GetFilter() *Filter {
if m != nil {
return m.Filter
}
return nil
}
type FirstKeyOnlyFilter struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *FirstKeyOnlyFilter) Reset() { *m = FirstKeyOnlyFilter{} }
func (m *FirstKeyOnlyFilter) String() string { return proto1.CompactTextString(m) }
func (*FirstKeyOnlyFilter) ProtoMessage() {}
type FirstKeyValueMatchingQualifiersFilter struct {
Qualifiers [][]byte `protobuf:"bytes,1,rep,name=qualifiers" json:"qualifiers,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *FirstKeyValueMatchingQualifiersFilter) Reset() { *m = FirstKeyValueMatchingQualifiersFilter{} }
func (m *FirstKeyValueMatchingQualifiersFilter) String() string { return proto1.CompactTextString(m) }
func (*FirstKeyValueMatchingQualifiersFilter) ProtoMessage() {}
func (m *FirstKeyValueMatchingQualifiersFilter) GetQualifiers() [][]byte {
if m != nil {
return m.Qualifiers
}
return nil
}
type FuzzyRowFilter struct {
FuzzyKeysData []*BytesBytesPair `protobuf:"bytes,1,rep,name=fuzzy_keys_data" json:"fuzzy_keys_data,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *FuzzyRowFilter) Reset() { *m = FuzzyRowFilter{} }
func (m *FuzzyRowFilter) String() string { return proto1.CompactTextString(m) }
func (*FuzzyRowFilter) ProtoMessage() {}
func (m *FuzzyRowFilter) GetFuzzyKeysData() []*BytesBytesPair {
if m != nil {
return m.FuzzyKeysData
}
return nil
}
type InclusiveStopFilter struct {
StopRowKey []byte `protobuf:"bytes,1,opt,name=stop_row_key" json:"stop_row_key,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *InclusiveStopFilter) Reset() { *m = InclusiveStopFilter{} }
func (m *InclusiveStopFilter) String() string { return proto1.CompactTextString(m) }
func (*InclusiveStopFilter) ProtoMessage() {}
func (m *InclusiveStopFilter) GetStopRowKey() []byte {
if m != nil {
return m.StopRowKey
}
return nil
}
type KeyOnlyFilter struct {
LenAsVal *bool `protobuf:"varint,1,req,name=len_as_val" json:"len_as_val,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *KeyOnlyFilter) Reset() { *m = KeyOnlyFilter{} }
func (m *KeyOnlyFilter) String() string { return proto1.CompactTextString(m) }
func (*KeyOnlyFilter) ProtoMessage() {}
func (m *KeyOnlyFilter) GetLenAsVal() bool {
if m != nil && m.LenAsVal != nil {
return *m.LenAsVal
}
return false
}
type MultipleColumnPrefixFilter struct {
SortedPrefixes [][]byte `protobuf:"bytes,1,rep,name=sorted_prefixes" json:"sorted_prefixes,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *MultipleColumnPrefixFilter) Reset() { *m = MultipleColumnPrefixFilter{} }
func (m *MultipleColumnPrefixFilter) String() string { return proto1.CompactTextString(m) }
func (*MultipleColumnPrefixFilter) ProtoMessage() {}
func (m *MultipleColumnPrefixFilter) GetSortedPrefixes() [][]byte {
if m != nil {
return m.SortedPrefixes
}
return nil
}
type PageFilter struct {
PageSize *int64 `protobuf:"varint,1,req,name=page_size" json:"page_size,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *PageFilter) Reset() { *m = PageFilter{} }
func (m *PageFilter) String() string { return proto1.CompactTextString(m) }
func (*PageFilter) ProtoMessage() {}
func (m *PageFilter) GetPageSize() int64 {
if m != nil && m.PageSize != nil {
return *m.PageSize
}
return 0
}
type PrefixFilter struct {
Prefix []byte `protobuf:"bytes,1,opt,name=prefix" json:"prefix,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *PrefixFilter) Reset() { *m = PrefixFilter{} }
func (m *PrefixFilter) String() string { return proto1.CompactTextString(m) }
func (*PrefixFilter) ProtoMessage() {}
func (m *PrefixFilter) GetPrefix() []byte {
if m != nil {
return m.Prefix
}
return nil
}
type QualifierFilter struct {
CompareFilter *CompareFilter `protobuf:"bytes,1,req,name=compare_filter" json:"compare_filter,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *QualifierFilter) Reset() { *m = QualifierFilter{} }
func (m *QualifierFilter) String() string { return proto1.CompactTextString(m) }
func (*QualifierFilter) ProtoMessage() {}
func (m *QualifierFilter) GetCompareFilter() *CompareFilter {
if m != nil {
return m.CompareFilter
}
return nil
}
type RandomRowFilter struct {
Chance *float32 `protobuf:"fixed32,1,req,name=chance" json:"chance,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *RandomRowFilter) Reset() { *m = RandomRowFilter{} }
func (m *RandomRowFilter) String() string { return proto1.CompactTextString(m) }
func (*RandomRowFilter) ProtoMessage() {}
func (m *RandomRowFilter) GetChance() float32 {
if m != nil && m.Chance != nil {
return *m.Chance
}
return 0
}
type RowFilter struct {
CompareFilter *CompareFilter `protobuf:"bytes,1,req,name=compare_filter" json:"compare_filter,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *RowFilter) Reset() { *m = RowFilter{} }
func (m *RowFilter) String() string { return proto1.CompactTextString(m) }
func (*RowFilter) ProtoMessage() {}
func (m *RowFilter) GetCompareFilter() *CompareFilter {
if m != nil {
return m.CompareFilter
}
return nil
}
type SingleColumnValueExcludeFilter struct {
SingleColumnValueFilter *SingleColumnValueFilter `protobuf:"bytes,1,req,name=single_column_value_filter" json:"single_column_value_filter,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *SingleColumnValueExcludeFilter) Reset() { *m = SingleColumnValueExcludeFilter{} }
func (m *SingleColumnValueExcludeFilter) String() string { return proto1.CompactTextString(m) }
func (*SingleColumnValueExcludeFilter) ProtoMessage() {}
func (m *SingleColumnValueExcludeFilter) GetSingleColumnValueFilter() *SingleColumnValueFilter {
if m != nil {
return m.SingleColumnValueFilter
}
return nil
}
type SingleColumnValueFilter struct {
ColumnFamily []byte `protobuf:"bytes,1,opt,name=column_family" json:"column_family,omitempty"`
ColumnQualifier []byte `protobuf:"bytes,2,opt,name=column_qualifier" json:"column_qualifier,omitempty"`
CompareOp *CompareType `protobuf:"varint,3,req,name=compare_op,enum=proto.CompareType" json:"compare_op,omitempty"`
Comparator *Comparator `protobuf:"bytes,4,req,name=comparator" json:"comparator,omitempty"`
FilterIfMissing *bool `protobuf:"varint,5,opt,name=filter_if_missing" json:"filter_if_missing,omitempty"`
LatestVersionOnly *bool `protobuf:"varint,6,opt,name=latest_version_only" json:"latest_version_only,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *SingleColumnValueFilter) Reset() { *m = SingleColumnValueFilter{} }
func (m *SingleColumnValueFilter) String() string { return proto1.CompactTextString(m) }
func (*SingleColumnValueFilter) ProtoMessage() {}
func (m *SingleColumnValueFilter) GetColumnFamily() []byte {
if m != nil {
return m.ColumnFamily
}
return nil
}
func (m *SingleColumnValueFilter) GetColumnQualifier() []byte {
if m != nil {
return m.ColumnQualifier
}
return nil
}
func (m *SingleColumnValueFilter) GetCompareOp() CompareType {
if m != nil && m.CompareOp != nil {
return *m.CompareOp
}
return CompareType_LESS
}
func (m *SingleColumnValueFilter) GetComparator() *Comparator {
if m != nil {
return m.Comparator
}
return nil
}
func (m *SingleColumnValueFilter) GetFilterIfMissing() bool {
if m != nil && m.FilterIfMissing != nil {
return *m.FilterIfMissing
}
return false
}
func (m *SingleColumnValueFilter) GetLatestVersionOnly() bool {
if m != nil && m.LatestVersionOnly != nil {
return *m.LatestVersionOnly
}
return false
}
type SkipFilter struct {
Filter *Filter `protobuf:"bytes,1,req,name=filter" json:"filter,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *SkipFilter) Reset() { *m = SkipFilter{} }
func (m *SkipFilter) String() string { return proto1.CompactTextString(m) }
func (*SkipFilter) ProtoMessage() {}
func (m *SkipFilter) GetFilter() *Filter {
if m != nil {
return m.Filter
}
return nil
}
type TimestampsFilter struct {
Timestamps []int64 `protobuf:"varint,1,rep,packed,name=timestamps" json:"timestamps,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TimestampsFilter) Reset() { *m = TimestampsFilter{} }
func (m *TimestampsFilter) String() string { return proto1.CompactTextString(m) }
func (*TimestampsFilter) ProtoMessage() {}
func (m *TimestampsFilter) GetTimestamps() []int64 {
if m != nil {
return m.Timestamps
}
return nil
}
type ValueFilter struct {
CompareFilter *CompareFilter `protobuf:"bytes,1,req,name=compare_filter" json:"compare_filter,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ValueFilter) Reset() { *m = ValueFilter{} }
func (m *ValueFilter) String() string { return proto1.CompactTextString(m) }
func (*ValueFilter) ProtoMessage() {}
func (m *ValueFilter) GetCompareFilter() *CompareFilter {
if m != nil {
return m.CompareFilter
}
return nil
}
type WhileMatchFilter struct {
Filter *Filter `protobuf:"bytes,1,req,name=filter" json:"filter,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *WhileMatchFilter) Reset() { *m = WhileMatchFilter{} }
func (m *WhileMatchFilter) String() string { return proto1.CompactTextString(m) }
func (*WhileMatchFilter) ProtoMessage() {}
func (m *WhileMatchFilter) GetFilter() *Filter {
if m != nil {
return m.Filter
}
return nil
}
type FilterAllFilter struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *FilterAllFilter) Reset() { *m = FilterAllFilter{} }
func (m *FilterAllFilter) String() string { return proto1.CompactTextString(m) }
func (*FilterAllFilter) ProtoMessage() {}
func init() {
proto1.RegisterEnum("proto.FilterList_Operator", FilterList_Operator_name, FilterList_Operator_value)
}

741
vendor/github.com/pingcap/go-hbase/proto/HBase.pb.go generated vendored
View file

@ -1,741 +0,0 @@
// Code generated by protoc-gen-go.
// source: HBase.proto
// DO NOT EDIT!
package proto
import proto1 "github.com/golang/protobuf/proto"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto1.Marshal
var _ = math.Inf
// Comparison operators
type CompareType int32
const (
CompareType_LESS CompareType = 0
CompareType_LESS_OR_EQUAL CompareType = 1
CompareType_EQUAL CompareType = 2
CompareType_NOT_EQUAL CompareType = 3
CompareType_GREATER_OR_EQUAL CompareType = 4
CompareType_GREATER CompareType = 5
CompareType_NO_OP CompareType = 6
)
var CompareType_name = map[int32]string{
0: "LESS",
1: "LESS_OR_EQUAL",
2: "EQUAL",
3: "NOT_EQUAL",
4: "GREATER_OR_EQUAL",
5: "GREATER",
6: "NO_OP",
}
var CompareType_value = map[string]int32{
"LESS": 0,
"LESS_OR_EQUAL": 1,
"EQUAL": 2,
"NOT_EQUAL": 3,
"GREATER_OR_EQUAL": 4,
"GREATER": 5,
"NO_OP": 6,
}
func (x CompareType) Enum() *CompareType {
p := new(CompareType)
*p = x
return p
}
func (x CompareType) String() string {
return proto1.EnumName(CompareType_name, int32(x))
}
func (x *CompareType) UnmarshalJSON(data []byte) error {
value, err := proto1.UnmarshalJSONEnum(CompareType_value, data, "CompareType")
if err != nil {
return err
}
*x = CompareType(value)
return nil
}
type RegionSpecifier_RegionSpecifierType int32
const (
// <tablename>,<startkey>,<regionId>.<encodedName>
RegionSpecifier_REGION_NAME RegionSpecifier_RegionSpecifierType = 1
// hash of <tablename>,<startkey>,<regionId>
RegionSpecifier_ENCODED_REGION_NAME RegionSpecifier_RegionSpecifierType = 2
)
var RegionSpecifier_RegionSpecifierType_name = map[int32]string{
1: "REGION_NAME",
2: "ENCODED_REGION_NAME",
}
var RegionSpecifier_RegionSpecifierType_value = map[string]int32{
"REGION_NAME": 1,
"ENCODED_REGION_NAME": 2,
}
func (x RegionSpecifier_RegionSpecifierType) Enum() *RegionSpecifier_RegionSpecifierType {
p := new(RegionSpecifier_RegionSpecifierType)
*p = x
return p
}
func (x RegionSpecifier_RegionSpecifierType) String() string {
return proto1.EnumName(RegionSpecifier_RegionSpecifierType_name, int32(x))
}
func (x *RegionSpecifier_RegionSpecifierType) UnmarshalJSON(data []byte) error {
value, err := proto1.UnmarshalJSONEnum(RegionSpecifier_RegionSpecifierType_value, data, "RegionSpecifier_RegionSpecifierType")
if err != nil {
return err
}
*x = RegionSpecifier_RegionSpecifierType(value)
return nil
}
type SnapshotDescription_Type int32
const (
SnapshotDescription_DISABLED SnapshotDescription_Type = 0
SnapshotDescription_FLUSH SnapshotDescription_Type = 1
SnapshotDescription_SKIPFLUSH SnapshotDescription_Type = 2
)
var SnapshotDescription_Type_name = map[int32]string{
0: "DISABLED",
1: "FLUSH",
2: "SKIPFLUSH",
}
var SnapshotDescription_Type_value = map[string]int32{
"DISABLED": 0,
"FLUSH": 1,
"SKIPFLUSH": 2,
}
func (x SnapshotDescription_Type) Enum() *SnapshotDescription_Type {
p := new(SnapshotDescription_Type)
*p = x
return p
}
func (x SnapshotDescription_Type) String() string {
return proto1.EnumName(SnapshotDescription_Type_name, int32(x))
}
func (x *SnapshotDescription_Type) UnmarshalJSON(data []byte) error {
value, err := proto1.UnmarshalJSONEnum(SnapshotDescription_Type_value, data, "SnapshotDescription_Type")
if err != nil {
return err
}
*x = SnapshotDescription_Type(value)
return nil
}
// *
// Table Name
type TableName struct {
Namespace []byte `protobuf:"bytes,1,req,name=namespace" json:"namespace,omitempty"`
Qualifier []byte `protobuf:"bytes,2,req,name=qualifier" json:"qualifier,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TableName) Reset() { *m = TableName{} }
func (m *TableName) String() string { return proto1.CompactTextString(m) }
func (*TableName) ProtoMessage() {}
func (m *TableName) GetNamespace() []byte {
if m != nil {
return m.Namespace
}
return nil
}
func (m *TableName) GetQualifier() []byte {
if m != nil {
return m.Qualifier
}
return nil
}
// *
// Table Schema
// Inspired by the rest TableSchema
type TableSchema struct {
TableName *TableName `protobuf:"bytes,1,opt,name=table_name" json:"table_name,omitempty"`
Attributes []*BytesBytesPair `protobuf:"bytes,2,rep,name=attributes" json:"attributes,omitempty"`
ColumnFamilies []*ColumnFamilySchema `protobuf:"bytes,3,rep,name=column_families" json:"column_families,omitempty"`
Configuration []*NameStringPair `protobuf:"bytes,4,rep,name=configuration" json:"configuration,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TableSchema) Reset() { *m = TableSchema{} }
func (m *TableSchema) String() string { return proto1.CompactTextString(m) }
func (*TableSchema) ProtoMessage() {}
func (m *TableSchema) GetTableName() *TableName {
if m != nil {
return m.TableName
}
return nil
}
func (m *TableSchema) GetAttributes() []*BytesBytesPair {
if m != nil {
return m.Attributes
}
return nil
}
func (m *TableSchema) GetColumnFamilies() []*ColumnFamilySchema {
if m != nil {
return m.ColumnFamilies
}
return nil
}
func (m *TableSchema) GetConfiguration() []*NameStringPair {
if m != nil {
return m.Configuration
}
return nil
}
// *
// Column Family Schema
// Inspired by the rest ColumSchemaMessage
type ColumnFamilySchema struct {
Name []byte `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
Attributes []*BytesBytesPair `protobuf:"bytes,2,rep,name=attributes" json:"attributes,omitempty"`
Configuration []*NameStringPair `protobuf:"bytes,3,rep,name=configuration" json:"configuration,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ColumnFamilySchema) Reset() { *m = ColumnFamilySchema{} }
func (m *ColumnFamilySchema) String() string { return proto1.CompactTextString(m) }
func (*ColumnFamilySchema) ProtoMessage() {}
func (m *ColumnFamilySchema) GetName() []byte {
if m != nil {
return m.Name
}
return nil
}
func (m *ColumnFamilySchema) GetAttributes() []*BytesBytesPair {
if m != nil {
return m.Attributes
}
return nil
}
func (m *ColumnFamilySchema) GetConfiguration() []*NameStringPair {
if m != nil {
return m.Configuration
}
return nil
}
// *
// Protocol buffer version of HRegionInfo.
type RegionInfo struct {
RegionId *uint64 `protobuf:"varint,1,req,name=region_id" json:"region_id,omitempty"`
TableName *TableName `protobuf:"bytes,2,req,name=table_name" json:"table_name,omitempty"`
StartKey []byte `protobuf:"bytes,3,opt,name=start_key" json:"start_key,omitempty"`
EndKey []byte `protobuf:"bytes,4,opt,name=end_key" json:"end_key,omitempty"`
Offline *bool `protobuf:"varint,5,opt,name=offline" json:"offline,omitempty"`
Split *bool `protobuf:"varint,6,opt,name=split" json:"split,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *RegionInfo) Reset() { *m = RegionInfo{} }
func (m *RegionInfo) String() string { return proto1.CompactTextString(m) }
func (*RegionInfo) ProtoMessage() {}
func (m *RegionInfo) GetRegionId() uint64 {
if m != nil && m.RegionId != nil {
return *m.RegionId
}
return 0
}
func (m *RegionInfo) GetTableName() *TableName {
if m != nil {
return m.TableName
}
return nil
}
func (m *RegionInfo) GetStartKey() []byte {
if m != nil {
return m.StartKey
}
return nil
}
func (m *RegionInfo) GetEndKey() []byte {
if m != nil {
return m.EndKey
}
return nil
}
func (m *RegionInfo) GetOffline() bool {
if m != nil && m.Offline != nil {
return *m.Offline
}
return false
}
func (m *RegionInfo) GetSplit() bool {
if m != nil && m.Split != nil {
return *m.Split
}
return false
}
// *
// Protocol buffer for favored nodes
type FavoredNodes struct {
FavoredNode []*ServerName `protobuf:"bytes,1,rep,name=favored_node" json:"favored_node,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *FavoredNodes) Reset() { *m = FavoredNodes{} }
func (m *FavoredNodes) String() string { return proto1.CompactTextString(m) }
func (*FavoredNodes) ProtoMessage() {}
func (m *FavoredNodes) GetFavoredNode() []*ServerName {
if m != nil {
return m.FavoredNode
}
return nil
}
// *
// Container protocol buffer to specify a region.
// You can specify region by region name, or the hash
// of the region name, which is known as encoded
// region name.
type RegionSpecifier struct {
Type *RegionSpecifier_RegionSpecifierType `protobuf:"varint,1,req,name=type,enum=proto.RegionSpecifier_RegionSpecifierType" json:"type,omitempty"`
Value []byte `protobuf:"bytes,2,req,name=value" json:"value,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *RegionSpecifier) Reset() { *m = RegionSpecifier{} }
func (m *RegionSpecifier) String() string { return proto1.CompactTextString(m) }
func (*RegionSpecifier) ProtoMessage() {}
func (m *RegionSpecifier) GetType() RegionSpecifier_RegionSpecifierType {
if m != nil && m.Type != nil {
return *m.Type
}
return RegionSpecifier_REGION_NAME
}
func (m *RegionSpecifier) GetValue() []byte {
if m != nil {
return m.Value
}
return nil
}
// *
// A range of time. Both from and to are Java time
// stamp in milliseconds. If you don't specify a time
// range, it means all time. By default, if not
// specified, from = 0, and to = Long.MAX_VALUE
type TimeRange struct {
From *uint64 `protobuf:"varint,1,opt,name=from" json:"from,omitempty"`
To *uint64 `protobuf:"varint,2,opt,name=to" json:"to,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TimeRange) Reset() { *m = TimeRange{} }
func (m *TimeRange) String() string { return proto1.CompactTextString(m) }
func (*TimeRange) ProtoMessage() {}
func (m *TimeRange) GetFrom() uint64 {
if m != nil && m.From != nil {
return *m.From
}
return 0
}
func (m *TimeRange) GetTo() uint64 {
if m != nil && m.To != nil {
return *m.To
}
return 0
}
// *
// Protocol buffer version of ServerName
type ServerName struct {
HostName *string `protobuf:"bytes,1,req,name=host_name" json:"host_name,omitempty"`
Port *uint32 `protobuf:"varint,2,opt,name=port" json:"port,omitempty"`
StartCode *uint64 `protobuf:"varint,3,opt,name=start_code" json:"start_code,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ServerName) Reset() { *m = ServerName{} }
func (m *ServerName) String() string { return proto1.CompactTextString(m) }
func (*ServerName) ProtoMessage() {}
func (m *ServerName) GetHostName() string {
if m != nil && m.HostName != nil {
return *m.HostName
}
return ""
}
func (m *ServerName) GetPort() uint32 {
if m != nil && m.Port != nil {
return *m.Port
}
return 0
}
func (m *ServerName) GetStartCode() uint64 {
if m != nil && m.StartCode != nil {
return *m.StartCode
}
return 0
}
type Coprocessor struct {
Name *string `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Coprocessor) Reset() { *m = Coprocessor{} }
func (m *Coprocessor) String() string { return proto1.CompactTextString(m) }
func (*Coprocessor) ProtoMessage() {}
func (m *Coprocessor) GetName() string {
if m != nil && m.Name != nil {
return *m.Name
}
return ""
}
type NameStringPair struct {
Name *string `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
Value *string `protobuf:"bytes,2,req,name=value" json:"value,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *NameStringPair) Reset() { *m = NameStringPair{} }
func (m *NameStringPair) String() string { return proto1.CompactTextString(m) }
func (*NameStringPair) ProtoMessage() {}
func (m *NameStringPair) GetName() string {
if m != nil && m.Name != nil {
return *m.Name
}
return ""
}
func (m *NameStringPair) GetValue() string {
if m != nil && m.Value != nil {
return *m.Value
}
return ""
}
type NameBytesPair struct {
Name *string `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
Value []byte `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *NameBytesPair) Reset() { *m = NameBytesPair{} }
func (m *NameBytesPair) String() string { return proto1.CompactTextString(m) }
func (*NameBytesPair) ProtoMessage() {}
func (m *NameBytesPair) GetName() string {
if m != nil && m.Name != nil {
return *m.Name
}
return ""
}
func (m *NameBytesPair) GetValue() []byte {
if m != nil {
return m.Value
}
return nil
}
type BytesBytesPair struct {
First []byte `protobuf:"bytes,1,req,name=first" json:"first,omitempty"`
Second []byte `protobuf:"bytes,2,req,name=second" json:"second,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *BytesBytesPair) Reset() { *m = BytesBytesPair{} }
func (m *BytesBytesPair) String() string { return proto1.CompactTextString(m) }
func (*BytesBytesPair) ProtoMessage() {}
func (m *BytesBytesPair) GetFirst() []byte {
if m != nil {
return m.First
}
return nil
}
func (m *BytesBytesPair) GetSecond() []byte {
if m != nil {
return m.Second
}
return nil
}
type NameInt64Pair struct {
Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
Value *int64 `protobuf:"varint,2,opt,name=value" json:"value,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *NameInt64Pair) Reset() { *m = NameInt64Pair{} }
func (m *NameInt64Pair) String() string { return proto1.CompactTextString(m) }
func (*NameInt64Pair) ProtoMessage() {}
func (m *NameInt64Pair) GetName() string {
if m != nil && m.Name != nil {
return *m.Name
}
return ""
}
func (m *NameInt64Pair) GetValue() int64 {
if m != nil && m.Value != nil {
return *m.Value
}
return 0
}
// *
// Description of the snapshot to take
type SnapshotDescription struct {
Name *string `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
Table *string `protobuf:"bytes,2,opt,name=table" json:"table,omitempty"`
CreationTime *int64 `protobuf:"varint,3,opt,name=creation_time,def=0" json:"creation_time,omitempty"`
Type *SnapshotDescription_Type `protobuf:"varint,4,opt,name=type,enum=proto.SnapshotDescription_Type,def=1" json:"type,omitempty"`
Version *int32 `protobuf:"varint,5,opt,name=version" json:"version,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *SnapshotDescription) Reset() { *m = SnapshotDescription{} }
func (m *SnapshotDescription) String() string { return proto1.CompactTextString(m) }
func (*SnapshotDescription) ProtoMessage() {}
const Default_SnapshotDescription_CreationTime int64 = 0
const Default_SnapshotDescription_Type SnapshotDescription_Type = SnapshotDescription_FLUSH
func (m *SnapshotDescription) GetName() string {
if m != nil && m.Name != nil {
return *m.Name
}
return ""
}
func (m *SnapshotDescription) GetTable() string {
if m != nil && m.Table != nil {
return *m.Table
}
return ""
}
func (m *SnapshotDescription) GetCreationTime() int64 {
if m != nil && m.CreationTime != nil {
return *m.CreationTime
}
return Default_SnapshotDescription_CreationTime
}
func (m *SnapshotDescription) GetType() SnapshotDescription_Type {
if m != nil && m.Type != nil {
return *m.Type
}
return Default_SnapshotDescription_Type
}
func (m *SnapshotDescription) GetVersion() int32 {
if m != nil && m.Version != nil {
return *m.Version
}
return 0
}
// *
// Description of the distributed procedure to take
type ProcedureDescription struct {
Signature *string `protobuf:"bytes,1,req,name=signature" json:"signature,omitempty"`
Instance *string `protobuf:"bytes,2,opt,name=instance" json:"instance,omitempty"`
CreationTime *int64 `protobuf:"varint,3,opt,name=creation_time,def=0" json:"creation_time,omitempty"`
Configuration []*NameStringPair `protobuf:"bytes,4,rep,name=configuration" json:"configuration,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ProcedureDescription) Reset() { *m = ProcedureDescription{} }
func (m *ProcedureDescription) String() string { return proto1.CompactTextString(m) }
func (*ProcedureDescription) ProtoMessage() {}
const Default_ProcedureDescription_CreationTime int64 = 0
func (m *ProcedureDescription) GetSignature() string {
if m != nil && m.Signature != nil {
return *m.Signature
}
return ""
}
func (m *ProcedureDescription) GetInstance() string {
if m != nil && m.Instance != nil {
return *m.Instance
}
return ""
}
func (m *ProcedureDescription) GetCreationTime() int64 {
if m != nil && m.CreationTime != nil {
return *m.CreationTime
}
return Default_ProcedureDescription_CreationTime
}
func (m *ProcedureDescription) GetConfiguration() []*NameStringPair {
if m != nil {
return m.Configuration
}
return nil
}
type EmptyMsg struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *EmptyMsg) Reset() { *m = EmptyMsg{} }
func (m *EmptyMsg) String() string { return proto1.CompactTextString(m) }
func (*EmptyMsg) ProtoMessage() {}
type LongMsg struct {
LongMsg *int64 `protobuf:"varint,1,req,name=long_msg" json:"long_msg,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *LongMsg) Reset() { *m = LongMsg{} }
func (m *LongMsg) String() string { return proto1.CompactTextString(m) }
func (*LongMsg) ProtoMessage() {}
func (m *LongMsg) GetLongMsg() int64 {
if m != nil && m.LongMsg != nil {
return *m.LongMsg
}
return 0
}
type DoubleMsg struct {
DoubleMsg *float64 `protobuf:"fixed64,1,req,name=double_msg" json:"double_msg,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *DoubleMsg) Reset() { *m = DoubleMsg{} }
func (m *DoubleMsg) String() string { return proto1.CompactTextString(m) }
func (*DoubleMsg) ProtoMessage() {}
func (m *DoubleMsg) GetDoubleMsg() float64 {
if m != nil && m.DoubleMsg != nil {
return *m.DoubleMsg
}
return 0
}
type BigDecimalMsg struct {
BigdecimalMsg []byte `protobuf:"bytes,1,req,name=bigdecimal_msg" json:"bigdecimal_msg,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *BigDecimalMsg) Reset() { *m = BigDecimalMsg{} }
func (m *BigDecimalMsg) String() string { return proto1.CompactTextString(m) }
func (*BigDecimalMsg) ProtoMessage() {}
func (m *BigDecimalMsg) GetBigdecimalMsg() []byte {
if m != nil {
return m.BigdecimalMsg
}
return nil
}
type UUID struct {
LeastSigBits *uint64 `protobuf:"varint,1,req,name=least_sig_bits" json:"least_sig_bits,omitempty"`
MostSigBits *uint64 `protobuf:"varint,2,req,name=most_sig_bits" json:"most_sig_bits,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *UUID) Reset() { *m = UUID{} }
func (m *UUID) String() string { return proto1.CompactTextString(m) }
func (*UUID) ProtoMessage() {}
func (m *UUID) GetLeastSigBits() uint64 {
if m != nil && m.LeastSigBits != nil {
return *m.LeastSigBits
}
return 0
}
func (m *UUID) GetMostSigBits() uint64 {
if m != nil && m.MostSigBits != nil {
return *m.MostSigBits
}
return 0
}
type NamespaceDescriptor struct {
Name []byte `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
Configuration []*NameStringPair `protobuf:"bytes,2,rep,name=configuration" json:"configuration,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *NamespaceDescriptor) Reset() { *m = NamespaceDescriptor{} }
func (m *NamespaceDescriptor) String() string { return proto1.CompactTextString(m) }
func (*NamespaceDescriptor) ProtoMessage() {}
func (m *NamespaceDescriptor) GetName() []byte {
if m != nil {
return m.Name
}
return nil
}
func (m *NamespaceDescriptor) GetConfiguration() []*NameStringPair {
if m != nil {
return m.Configuration
}
return nil
}
// *
// Description of the region server info
type RegionServerInfo struct {
InfoPort *int32 `protobuf:"varint,1,opt,name=infoPort" json:"infoPort,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *RegionServerInfo) Reset() { *m = RegionServerInfo{} }
func (m *RegionServerInfo) String() string { return proto1.CompactTextString(m) }
func (*RegionServerInfo) ProtoMessage() {}
func (m *RegionServerInfo) GetInfoPort() int32 {
if m != nil && m.InfoPort != nil {
return *m.InfoPort
}
return 0
}
func init() {
proto1.RegisterEnum("proto.CompareType", CompareType_name, CompareType_value)
proto1.RegisterEnum("proto.RegionSpecifier_RegionSpecifierType", RegionSpecifier_RegionSpecifierType_name, RegionSpecifier_RegionSpecifierType_value)
proto1.RegisterEnum("proto.SnapshotDescription_Type", SnapshotDescription_Type_name, SnapshotDescription_Type_value)
}

145
vendor/github.com/pingcap/go-hbase/proto/HFile.pb.go generated vendored
View file

@ -1,145 +0,0 @@
// Code generated by protoc-gen-go.
// source: HFile.proto
// DO NOT EDIT!
package proto
import proto1 "github.com/golang/protobuf/proto"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto1.Marshal
var _ = math.Inf
// Map of name/values
type FileInfoProto struct {
MapEntry []*BytesBytesPair `protobuf:"bytes,1,rep,name=map_entry" json:"map_entry,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *FileInfoProto) Reset() { *m = FileInfoProto{} }
func (m *FileInfoProto) String() string { return proto1.CompactTextString(m) }
func (*FileInfoProto) ProtoMessage() {}
func (m *FileInfoProto) GetMapEntry() []*BytesBytesPair {
if m != nil {
return m.MapEntry
}
return nil
}
// HFile file trailer
type FileTrailerProto struct {
FileInfoOffset *uint64 `protobuf:"varint,1,opt,name=file_info_offset" json:"file_info_offset,omitempty"`
LoadOnOpenDataOffset *uint64 `protobuf:"varint,2,opt,name=load_on_open_data_offset" json:"load_on_open_data_offset,omitempty"`
UncompressedDataIndexSize *uint64 `protobuf:"varint,3,opt,name=uncompressed_data_index_size" json:"uncompressed_data_index_size,omitempty"`
TotalUncompressedBytes *uint64 `protobuf:"varint,4,opt,name=total_uncompressed_bytes" json:"total_uncompressed_bytes,omitempty"`
DataIndexCount *uint32 `protobuf:"varint,5,opt,name=data_index_count" json:"data_index_count,omitempty"`
MetaIndexCount *uint32 `protobuf:"varint,6,opt,name=meta_index_count" json:"meta_index_count,omitempty"`
EntryCount *uint64 `protobuf:"varint,7,opt,name=entry_count" json:"entry_count,omitempty"`
NumDataIndexLevels *uint32 `protobuf:"varint,8,opt,name=num_data_index_levels" json:"num_data_index_levels,omitempty"`
FirstDataBlockOffset *uint64 `protobuf:"varint,9,opt,name=first_data_block_offset" json:"first_data_block_offset,omitempty"`
LastDataBlockOffset *uint64 `protobuf:"varint,10,opt,name=last_data_block_offset" json:"last_data_block_offset,omitempty"`
ComparatorClassName *string `protobuf:"bytes,11,opt,name=comparator_class_name" json:"comparator_class_name,omitempty"`
CompressionCodec *uint32 `protobuf:"varint,12,opt,name=compression_codec" json:"compression_codec,omitempty"`
EncryptionKey []byte `protobuf:"bytes,13,opt,name=encryption_key" json:"encryption_key,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *FileTrailerProto) Reset() { *m = FileTrailerProto{} }
func (m *FileTrailerProto) String() string { return proto1.CompactTextString(m) }
func (*FileTrailerProto) ProtoMessage() {}
func (m *FileTrailerProto) GetFileInfoOffset() uint64 {
if m != nil && m.FileInfoOffset != nil {
return *m.FileInfoOffset
}
return 0
}
func (m *FileTrailerProto) GetLoadOnOpenDataOffset() uint64 {
if m != nil && m.LoadOnOpenDataOffset != nil {
return *m.LoadOnOpenDataOffset
}
return 0
}
func (m *FileTrailerProto) GetUncompressedDataIndexSize() uint64 {
if m != nil && m.UncompressedDataIndexSize != nil {
return *m.UncompressedDataIndexSize
}
return 0
}
func (m *FileTrailerProto) GetTotalUncompressedBytes() uint64 {
if m != nil && m.TotalUncompressedBytes != nil {
return *m.TotalUncompressedBytes
}
return 0
}
func (m *FileTrailerProto) GetDataIndexCount() uint32 {
if m != nil && m.DataIndexCount != nil {
return *m.DataIndexCount
}
return 0
}
func (m *FileTrailerProto) GetMetaIndexCount() uint32 {
if m != nil && m.MetaIndexCount != nil {
return *m.MetaIndexCount
}
return 0
}
func (m *FileTrailerProto) GetEntryCount() uint64 {
if m != nil && m.EntryCount != nil {
return *m.EntryCount
}
return 0
}
func (m *FileTrailerProto) GetNumDataIndexLevels() uint32 {
if m != nil && m.NumDataIndexLevels != nil {
return *m.NumDataIndexLevels
}
return 0
}
func (m *FileTrailerProto) GetFirstDataBlockOffset() uint64 {
if m != nil && m.FirstDataBlockOffset != nil {
return *m.FirstDataBlockOffset
}
return 0
}
func (m *FileTrailerProto) GetLastDataBlockOffset() uint64 {
if m != nil && m.LastDataBlockOffset != nil {
return *m.LastDataBlockOffset
}
return 0
}
func (m *FileTrailerProto) GetComparatorClassName() string {
if m != nil && m.ComparatorClassName != nil {
return *m.ComparatorClassName
}
return ""
}
func (m *FileTrailerProto) GetCompressionCodec() uint32 {
if m != nil && m.CompressionCodec != nil {
return *m.CompressionCodec
}
return 0
}
func (m *FileTrailerProto) GetEncryptionKey() []byte {
if m != nil {
return m.EncryptionKey
}
return nil
}
func init() {
}

Some files were not shown because too many files have changed in this diff Show more