@ -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") | |||
} |
@ -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. |
@ -1,5 +0,0 @@ | |||
CoreOS Project | |||
Copyright 2014 CoreOS, Inc | |||
This product includes software developed at CoreOS, Inc. | |||
(http://www.coreos.com/). |
@ -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()) | |||
} |
@ -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. |
@ -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() | |||
} |
@ -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 | |||
} |
@ -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)) | |||
} |
@ -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 | |||
} |
@ -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 | |||
} |
@ -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)) | |||
} |
@ -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) | |||
} |
@ -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 | |||
} |
@ -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) | |||
} |
@ -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 | |||
} |
@ -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 | |||
} |
@ -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 | |||
} |
@ -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] | |||
} |
@ -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) | |||
} |
@ -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 | |||
} |
@ -1,6 +0,0 @@ | |||
package etcd | |||
const ( | |||
version = "v2" | |||
packageVersion = "v2.0.0+git" | |||
) |
@ -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 | |||
} |
@ -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{}} | |||
} |
@ -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 | |||
} |
@ -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. |
@ -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 |
@ -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) | |||
} |
@ -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 ¬Found{wrap(nil, format, " not found", args...)} | |||
} | |||
// NewNotFound returns an error which wraps err that satisfies | |||
// IsNotFound(). | |||
func NewNotFound(err error, msg string) error { | |||
return ¬Found{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 ¬Implemented{wrap(nil, format, " not implemented", args...)} | |||
} | |||
// NewNotImplemented returns an error which wraps err and satisfies | |||
// IsNotImplemented(). | |||
func NewNotImplemented(err error, msg string) error { | |||
return ¬Implemented{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 ¬Supported{wrap(nil, format, " not supported", args...)} | |||
} | |||
// NewNotSupported returns an error which wraps err and satisfies | |||
// IsNotSupported(). | |||
func NewNotSupported(err error, msg string) error { | |||
return ¬Supported{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 ¬Valid{wrap(nil, format, " not valid", args...)} | |||
} | |||
// NewNotValid returns an error which wraps err and satisfies IsNotValid(). | |||
func NewNotValid(err error, msg string) error { | |||
return ¬Valid{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 ¬Provisioned{wrap(nil, format, " not provisioned", args...)} | |||
} | |||
// NewNotProvisioned returns an error which wraps err that satisfies | |||
// IsNotProvisioned(). | |||
func NewNotProvisioned(err error, msg string) error { | |||
return ¬Provisioned{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 ¬Assigned{wrap(nil, format, " not assigned", args...)} | |||
} | |||
// NewNotAssigned returns an error which wraps err that satisfies | |||
// IsNotAssigned(). | |||
func NewNotAssigned(err error, msg string) error { | |||
return ¬Assigned{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 | |||
} |
@ -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 | |||
} |
@ -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 | |||
} |
@ -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} | |||
} |
@ -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. |
@ -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 | |||
} |
@ -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" | |||
} |
@ -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 | |||
} |
@ -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 | |||
} |
@ -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() | |||
} |
@ -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 | |||
} |
@ -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) | |||
} | |||
} |
@ -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] | |||
} | |||
} |
@ -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. |
@ -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) | |||
} | |||
} |
@ -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) | |||
} | |||
} |
@ -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()) | |||
} | |||
} | |||
} |
@ -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} | |||
} |
@ -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 | |||
} |
@ -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)) | |||
} |
@ -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() | |||
} |
@ -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 | |||
} |
@ -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 | |||
} |
@ -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{}{} | |||
} | |||
} |
@ -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{}{} | |||
} |
@ -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 | |||
} | |||
} |
@ -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. | |||
@ -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 | |||
} |
@ -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) | |||
} |
@ -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 | |||
} |
@ -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 | |||
} |
@ -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 | |||
} |
@ -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 | |||
} |
@ -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() | |||
} |
@ -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") | |||
} |
@ -1,4 +0,0 @@ | |||
Petar Maymounkov <petar@5ttt.org> | |||
Vadim Vygonets <vadik@vygo.net> | |||
Ian Smith <iansmith@acm.org> | |||
Martin Bruse |
@ -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. |
@ -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()) } |
@ -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) | |||
} |
@ -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) | |||
} | |||
} |
@ -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 | |||
} |
@ -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) | |||
} |
@ -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. |
@ -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) | |||
} |
@ -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 | |||
} |
@ -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 | |||
} |
@ -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 | |||
} |
@ -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) | |||
} |
@ -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, | |||
} | |||
} |
@ -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() | |||
} |
@ -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 | |||
} |
@ -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 | |||
} |
@ -1,8 +0,0 @@ | |||
package iohelper | |||
import "io" | |||
type ByteMultiReader interface { | |||
io.ByteReader | |||
io.Reader | |||
} |
@ -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 | |||
} |
@ -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) | |||
} |
@ -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) | |||
} |
@ -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) | |||
} |
@ -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() { | |||
} |
@ -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) | |||
} |
@ -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) | |||
} |
@ -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() { | |||
} |
@ -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) | |||
} |
@ -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) | |||
} |
@ -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() { | |||
} |
@ -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() { | |||
} |
@ -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) | |||
} |
@ -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) | |||
} |
@ -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) | |||
} |
@ -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() { | |||
} |