├── .gitignore ├── LICENSE ├── README.md ├── build.gradle ├── docs └── diag.png ├── gradle.properties ├── gradle └── wrapper │ ├── gradle-wrapper.jar │ └── gradle-wrapper.properties ├── gradlew ├── gradlew.bat └── src ├── main ├── java │ └── org │ │ └── bitsofinfo │ │ └── hazelcast │ │ └── discovery │ │ └── etcd │ │ ├── BaseRegistrator.java │ │ ├── DoNothingRegistrator.java │ │ ├── EtcdDiscoveryConfiguration.java │ │ ├── EtcdDiscoveryStrategy.java │ │ ├── EtcdDiscoveryStrategyFactory.java │ │ ├── EtcdHazelcastNode.java │ │ ├── EtcdRegistrator.java │ │ ├── ExplicitIpPortRegistrator.java │ │ └── LocalDiscoveryNodeRegistrator.java └── resources │ ├── META-INF │ └── services │ │ └── com.hazelcast.spi.discovery.DiscoveryStrategyFactory │ ├── doNothingRegistrator-example.xml │ ├── explicitIpPortRegistrator-example.xml │ ├── hazelcast-etcd-discovery-spi-example.xml │ └── localDiscoveryNodeRegistrator-example.xml └── test ├── java └── org │ └── bitsofinfo │ └── hazelcast │ └── discovery │ └── etcd │ ├── ManualRunner.java │ ├── RegistratorTestBase.java │ ├── TestDoNothingRegistrator.java │ ├── TestExplicitIpPortRegistrator.java │ ├── TestLocalDiscoveryNodeRegistrator.java │ └── TestLocalDiscoveryNodeRegistratorWithUsernameAndPassword.java └── resources ├── test-DoNothingRegistrator.xml ├── test-ExplicitIpPortRegistrator.xml ├── test-LocalDiscoveryNodeRegistrator.xml └── test-LocalDiscoveryNodeRegistratorWithUsernameAndPassword.xml /.gitignore: -------------------------------------------------------------------------------- 1 | /bin/ 2 | /build/ 3 | /.settings/ 4 | /.classpath 5 | /.project 6 | /.gradle 7 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Apache License 2 | Version 2.0, January 2004 3 | http://www.apache.org/licenses/ 4 | 5 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 6 | 7 | 1. Definitions. 8 | 9 | "License" shall mean the terms and conditions for use, reproduction, 10 | and distribution as defined by Sections 1 through 9 of this document. 11 | 12 | "Licensor" shall mean the copyright owner or entity authorized by 13 | the copyright owner that is granting the License. 14 | 15 | "Legal Entity" shall mean the union of the acting entity and all 16 | other entities that control, are controlled by, or are under common 17 | control with that entity. For the purposes of this definition, 18 | "control" means (i) the power, direct or indirect, to cause the 19 | direction or management of such entity, whether by contract or 20 | otherwise, or (ii) ownership of fifty percent (50%) or more of the 21 | outstanding shares, or (iii) beneficial ownership of such entity. 22 | 23 | "You" (or "Your") shall mean an individual or Legal Entity 24 | exercising permissions granted by this License. 25 | 26 | "Source" form shall mean the preferred form for making modifications, 27 | including but not limited to software source code, documentation 28 | source, and configuration files. 29 | 30 | "Object" form shall mean any form resulting from mechanical 31 | transformation or translation of a Source form, including but 32 | not limited to compiled object code, generated documentation, 33 | and conversions to other media types. 34 | 35 | "Work" shall mean the work of authorship, whether in Source or 36 | Object form, made available under the License, as indicated by a 37 | copyright notice that is included in or attached to the work 38 | (an example is provided in the Appendix below). 39 | 40 | "Derivative Works" shall mean any work, whether in Source or Object 41 | form, that is based on (or derived from) the Work and for which the 42 | editorial revisions, annotations, elaborations, or other modifications 43 | represent, as a whole, an original work of authorship. For the purposes 44 | of this License, Derivative Works shall not include works that remain 45 | separable from, or merely link (or bind by name) to the interfaces of, 46 | the Work and Derivative Works thereof. 47 | 48 | "Contribution" shall mean any work of authorship, including 49 | the original version of the Work and any modifications or additions 50 | to that Work or Derivative Works thereof, that is intentionally 51 | submitted to Licensor for inclusion in the Work by the copyright owner 52 | or by an individual or Legal Entity authorized to submit on behalf of 53 | the copyright owner. For the purposes of this definition, "submitted" 54 | means any form of electronic, verbal, or written communication sent 55 | to the Licensor or its representatives, including but not limited to 56 | communication on electronic mailing lists, source code control systems, 57 | and issue tracking systems that are managed by, or on behalf of, the 58 | Licensor for the purpose of discussing and improving the Work, but 59 | excluding communication that is conspicuously marked or otherwise 60 | designated in writing by the copyright owner as "Not a Contribution." 61 | 62 | "Contributor" shall mean Licensor and any individual or Legal Entity 63 | on behalf of whom a Contribution has been received by Licensor and 64 | subsequently incorporated within the Work. 65 | 66 | 2. Grant of Copyright License. Subject to the terms and conditions of 67 | this License, each Contributor hereby grants to You a perpetual, 68 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 69 | copyright license to reproduce, prepare Derivative Works of, 70 | publicly display, publicly perform, sublicense, and distribute the 71 | Work and such Derivative Works in Source or Object form. 72 | 73 | 3. Grant of Patent License. Subject to the terms and conditions of 74 | this License, each Contributor hereby grants to You a perpetual, 75 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 76 | (except as stated in this section) patent license to make, have made, 77 | use, offer to sell, sell, import, and otherwise transfer the Work, 78 | where such license applies only to those patent claims licensable 79 | by such Contributor that are necessarily infringed by their 80 | Contribution(s) alone or by combination of their Contribution(s) 81 | with the Work to which such Contribution(s) was submitted. If You 82 | institute patent litigation against any entity (including a 83 | cross-claim or counterclaim in a lawsuit) alleging that the Work 84 | or a Contribution incorporated within the Work constitutes direct 85 | or contributory patent infringement, then any patent licenses 86 | granted to You under this License for that Work shall terminate 87 | as of the date such litigation is filed. 88 | 89 | 4. Redistribution. You may reproduce and distribute copies of the 90 | Work or Derivative Works thereof in any medium, with or without 91 | modifications, and in Source or Object form, provided that You 92 | meet the following conditions: 93 | 94 | (a) You must give any other recipients of the Work or 95 | Derivative Works a copy of this License; and 96 | 97 | (b) You must cause any modified files to carry prominent notices 98 | stating that You changed the files; and 99 | 100 | (c) You must retain, in the Source form of any Derivative Works 101 | that You distribute, all copyright, patent, trademark, and 102 | attribution notices from the Source form of the Work, 103 | excluding those notices that do not pertain to any part of 104 | the Derivative Works; and 105 | 106 | (d) If the Work includes a "NOTICE" text file as part of its 107 | distribution, then any Derivative Works that You distribute must 108 | include a readable copy of the attribution notices contained 109 | within such NOTICE file, excluding those notices that do not 110 | pertain to any part of the Derivative Works, in at least one 111 | of the following places: within a NOTICE text file distributed 112 | as part of the Derivative Works; within the Source form or 113 | documentation, if provided along with the Derivative Works; or, 114 | within a display generated by the Derivative Works, if and 115 | wherever such third-party notices normally appear. The contents 116 | of the NOTICE file are for informational purposes only and 117 | do not modify the License. You may add Your own attribution 118 | notices within Derivative Works that You distribute, alongside 119 | or as an addendum to the NOTICE text from the Work, provided 120 | that such additional attribution notices cannot be construed 121 | as modifying the License. 122 | 123 | You may add Your own copyright statement to Your modifications and 124 | may provide additional or different license terms and conditions 125 | for use, reproduction, or distribution of Your modifications, or 126 | for any such Derivative Works as a whole, provided Your use, 127 | reproduction, and distribution of the Work otherwise complies with 128 | the conditions stated in this License. 129 | 130 | 5. Submission of Contributions. Unless You explicitly state otherwise, 131 | any Contribution intentionally submitted for inclusion in the Work 132 | by You to the Licensor shall be under the terms and conditions of 133 | this License, without any additional terms or conditions. 134 | Notwithstanding the above, nothing herein shall supersede or modify 135 | the terms of any separate license agreement you may have executed 136 | with Licensor regarding such Contributions. 137 | 138 | 6. Trademarks. This License does not grant permission to use the trade 139 | names, trademarks, service marks, or product names of the Licensor, 140 | except as required for reasonable and customary use in describing the 141 | origin of the Work and reproducing the content of the NOTICE file. 142 | 143 | 7. Disclaimer of Warranty. Unless required by applicable law or 144 | agreed to in writing, Licensor provides the Work (and each 145 | Contributor provides its Contributions) on an "AS IS" BASIS, 146 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 147 | implied, including, without limitation, any warranties or conditions 148 | of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A 149 | PARTICULAR PURPOSE. You are solely responsible for determining the 150 | appropriateness of using or redistributing the Work and assume any 151 | risks associated with Your exercise of permissions under this License. 152 | 153 | 8. Limitation of Liability. In no event and under no legal theory, 154 | whether in tort (including negligence), contract, or otherwise, 155 | unless required by applicable law (such as deliberate and grossly 156 | negligent acts) or agreed to in writing, shall any Contributor be 157 | liable to You for damages, including any direct, indirect, special, 158 | incidental, or consequential damages of any character arising as a 159 | result of this License or out of the use or inability to use the 160 | Work (including but not limited to damages for loss of goodwill, 161 | work stoppage, computer failure or malfunction, or any and all 162 | other commercial damages or losses), even if such Contributor 163 | has been advised of the possibility of such damages. 164 | 165 | 9. Accepting Warranty or Additional Liability. While redistributing 166 | the Work or Derivative Works thereof, You may choose to offer, 167 | and charge a fee for, acceptance of support, warranty, indemnity, 168 | or other liability obligations and/or rights consistent with this 169 | License. However, in accepting such obligations, You may act only 170 | on Your own behalf and on Your sole responsibility, not on behalf 171 | of any other Contributor, and only if You agree to indemnify, 172 | defend, and hold each Contributor harmless for any liability 173 | incurred by, or claims asserted against, such Contributor by reason 174 | of your accepting any such warranty or additional liability. 175 | 176 | END OF TERMS AND CONDITIONS 177 | 178 | APPENDIX: How to apply the Apache License to your work. 179 | 180 | To apply the Apache License to your work, attach the following 181 | boilerplate notice, with the fields enclosed by brackets "{}" 182 | replaced with your own identifying information. (Don't include 183 | the brackets!) The text should be enclosed in the appropriate 184 | comment syntax for the file format. We also recommend that a 185 | file or class name and description of purpose be included on the 186 | same "printed page" as the copyright notice for easier 187 | identification within third-party archives. 188 | 189 | Copyright {yyyy} {name of copyright owner} 190 | 191 | Licensed under the Apache License, Version 2.0 (the "License"); 192 | you may not use this file except in compliance with the License. 193 | You may obtain a copy of the License at 194 | 195 | http://www.apache.org/licenses/LICENSE-2.0 196 | 197 | Unless required by applicable law or agreed to in writing, software 198 | distributed under the License is distributed on an "AS IS" BASIS, 199 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 200 | See the License for the specific language governing permissions and 201 | limitations under the License. 202 | 203 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # hazelcast-etcd-discovery-spi 2 | 3 | **IMPORTANT**: This README is relevant for the current *branch*/*tag* you have selected above. 4 | 5 | Provides a Etcd based discovery strategy for Hazlecast 3.6+ enabled applications. 6 | This is an easy to configure plug-and-play Hazlecast DiscoveryStrategy that will optionally register each of your Hazelcast instances with Etcd and enable Hazelcast nodes to dynamically discover one another via Etcd. 7 | 8 | * [Status](#status) 9 | * [Releases](#releases) 10 | * [Requirements](#requirements) 11 | * [Maven/Gradle install](#mavengradle) 12 | * [Features](#features) 13 | * [Usage](#usage) 14 | * [Build from source](#building) 15 | * [Unit tests](#tests) 16 | * [Related Info](#related) 17 | * [Todo](#todo) 18 | * [Notes](#notes) 19 | * [Docker info](#docker) 20 | 21 | ![Diagram of hazelcast etcd discovery strategy](/docs/diag.png "Diagram1") 22 | 23 | ## Status 24 | 25 | This is beta code, tested against Hazelcast 3.6-EA+ through 3.6 stable 26 | 27 | **IMPORTANT:**: Do not rely on JCenter/Bintray anymore! Update your gradle/maven dependencies to use Maven Central: https://search.maven.org/search?q=g:org.bitsofinfo 28 | 29 | ## Releases 30 | 31 | * **1.0-RC4-20210205**: Same as `1.0-RC4` but made compliant for Maven Central due to JCenter/Bintray closure. Includes explicit dependency of HZ `[3.6,3.12]` 32 | 33 | * [1.0-RC4](https://github.com/bitsofinfo/hazelcast-etcd-discovery-spi/releases/tag/1.0-RC4): Java 1.7+. SSL cert file improvements [pull/5](https://github.com/bitsofinfo/hazelcast-etcd-discovery-spi/pull/5) 34 | 35 | * [1.0-RC3](https://github.com/bitsofinfo/hazelcast-etcd-discovery-spi/releases/tag/1.0-RC3): Tested against Hazelcast 3.6-EA through 3.6 stable, add support for username and password for [issue #1](https://github.com/bitsofinfo/hazelcast-etcd-discovery-spi/issues/1) 36 | 37 | * [1.0-RC2](https://github.com/bitsofinfo/hazelcast-etcd-discovery-spi/releases/tag/1.0-RC2): Tested against Hazelcast 3.6-EA through 3.6 stable 38 | 39 | * [1.0-RC1](https://github.com/bitsofinfo/hazelcast-etcd-discovery-spi/releases/tag/1.0-RC1): Tested against Hazelcast 3.6-EA and 3.6-RC1 40 | 41 | ## Requirements 42 | 43 | * Java 7+ 44 | * [Hazelcast 3.6+](https://hazelcast.org/) 45 | * [Etcd](https://github.com/coreos/etcd) 46 | 47 | ## Maven/Gradle 48 | 49 | To use this discovery strategy in your Maven or Gradle project use the dependency samples below. 50 | 51 | ### Gradle: 52 | 53 | ``` 54 | repositories { 55 | mavenCentral() 56 | } 57 | 58 | dependencies { 59 | compile 'org.bitsofinfo:hazelcast-etcd-discovery-spi:1.0-RC4-20210205' 60 | } 61 | ``` 62 | 63 | ### Maven: 64 | 65 | ``` 66 | 67 | 68 | org.bitsofinfo 69 | hazelcast-etcd-discovery-spi 70 | 1.0-RC4-20210205 71 | 72 | 73 | ``` 74 | 75 | ## Features 76 | 77 | 78 | * Supports two modes of operation: 79 | * **Read-write**: peer discovery and registration of a hazelcast instance (self registration) 80 | * **Read-only**: peer discovery only with an manual Etcd key-path setup (no registration by the strategy itself) 81 | 82 | * If you don't want to use the built in Etcd registration, just specify the `DoNothingRegistrator` (see below) in your hazelcast discovery-strategy XML config. This will require you to manually create node key-paths against Etcd that defines the hazelcast service; in the format: 83 | * `/[etcd-service-name]/[hz-instance-id] = {"ip":"xx.xx.xx.xx", "hostname":"my.host", "port":5701}` where `hz-instance-id` can be anything but must be unique. 84 | * `etcd-service-name` must match the value of the `` in your hazelcast XML config for this discovery strategy. 85 | 86 | * If using self-registration, either `LocalDiscoveryNodeRegistrator` or `ExplicitIpPortRegistrator` which additionally support: 87 | * Automatic registration of the hazelcast instance with Etcd (under `` key) 88 | * Control which IP/PORT is published for the hazelcast node in Etcd 89 | * Configurable discovery delay 90 | * Automatic Etcd de-registration of instance via ShutdownHook 91 | 92 | ## Usage 93 | 94 | * Ensure your project has the `hazelcast-etcd-discovery-spi` artifact dependency declared in your maven pom or gradle build file as described above. Or build the jar yourself and ensure the jar is in your project's classpath. 95 | 96 | * Have Etcd running and available somewhere on your network, start it such as: 97 | ``` 98 | ./etcd 99 | ``` 100 | 101 | * Configure your hazelcast.xml configuration file to use the `EtcdDiscoveryStrategy` (similar to the below): [See hazelcast-etcd-discovery-spi-example.xml](src/main/resources/hazelcast-etcd-discovery-spi-example.xml) for a full example with documentation of options. 102 | 103 | * Launch your hazelcast instances, configured with the Etcd discovery-strategy similar to the below: [see ManualRunner.java](src/test/java/org/bitsofinfo/hazelcast/discovery/etcd/ManualRunner.java) example. 104 | 105 | 106 | ## Secured Communication 107 | 108 | By default, when the HTTPS protocol is defined in order to communicate with ETCD the standard SSLContext is used (usually using 'cacerts' system keystore, if not set otherwise). If you need to define your own 109 | SSLContext with custom certificates there are three optional parameters for defining input for a custom SSLContext in order to establish secure communication to ETCD. 110 | 111 | The optional security properties provide locations of certificates (and keys) for secure communication. You can configure trusted root certificates that are needed for communication with ETCD, when secure communication is enabled for your ETCD instance. You can also provide a client certificate and a private key through 'etcd-client-cert-location' and 'etcd-client-key-location' in case your ETCD has client-authentication activated and requests a client certificate. 112 | 113 | In case your root certificates and client certificate are chained in one file it is OK to define this file in 'etcd-client-cert-location' and omit the trusted-cert property. The implementation will extract the first certificate as your client certificate and the rest as the trusted root/intermediate certificates. 114 | 115 | Certificates should be X509 and provided in a PEM encoded file. Keys can be provided as PKCS#8 or PKCS#1 in a PEM encoded file. 116 | 117 | 118 | ``` 119 | 120 | 5701 121 | 122 | 123 | 124 | 125 | 126 | 127 | 128 | 130 | 131 | 132 | http://localhost:4001 133 | 134 | root 135 | 136 | password 137 | hz-discovery-test-cluster 138 | org.bitsofinfo.hazelcast.discovery.etcd.LocalDiscoveryNodeRegistrator 139 | 140 | /path/to/tls.crt 141 | /path/to/tls.key 142 | /path/to/trusted.crt 143 | 148 | 149 | 150 | 151 | 152 | 153 | 154 | ``` 155 | 156 | * Once nodes are joined you can query Etcd to see the auto-registration of hazelcast instances works, the service-id's generated etc 157 | 158 | ``` 159 | $ ./etcdctl ls hz-discovery-test-cluster 160 | /hz-discovery-test-cluster/hz-discovery-test-cluster-192.168.0.208-192.168.0.208-5701 161 | 162 | $ ./etcdctl get /hz-discovery-test-cluster/hz-discovery-test-cluster-192.168.0.208-192.168.0.208-5701 163 | {"ip":"192.168.0.208","port":5702,"hostname":"192.168.0.208","registeredAt":"2015.11.25 14:25:59.026 +0000"} 164 | ``` 165 | 166 | 167 | ## Build from source 168 | 169 | * From the root of this project, build a Jar : `./gradlew assemble` 170 | 171 | * Include the built jar artifact located at `build/libs/hazelcast-etcd-discovery-spi-[VERSION].jar` in your hazelcast project 172 | 173 | * If not already present in your hazelcast application's Maven (pom.xml) or Gradle (build.gradle) dependencies section; ensure that these dependencies are present (versions may vary as appropriate): 174 | 175 | ``` 176 | compile group: 'org.mousio', name: 'etcd4j', version:'2.9.0' 177 | compile group: 'com.google.code.gson', name: 'gson', version:'2.4' 178 | ``` 179 | 180 | 181 | ## Unit-tests 182 | 183 | It may also help you to understand the functionality by checking out and running the unit-tests 184 | located at [src/test/java](src/test/java). **BE SURE TO READ** the comments as some of the tests require 185 | you to setup your local Etcd and edit certain files. 186 | 187 | From the command line you can run `TestExplicitIpPortRegistrator` and `TestLocalDiscoveryNodeRegistrator` unit-tests by invoking the `runTests` task using `gradlew` that runs both tests and displays the result on the console. 188 | 189 | ``` 190 | $ ./gradlew runTests 191 | ``` 192 | 193 | The task above will display output indicating the test has started and whether the test has passed or failed. 194 | 195 | ###### Sample output for passing test: 196 | ``` 197 | org.bitsofinfo.hazelcast.discovery.etcd.TestExplicitIpPortRegistrator > testExplicitIpPortRegistrator STARTED 198 | 199 | org.bitsofinfo.hazelcast.discovery.etcd.TestExplicitIpPortRegistrator > testExplicitIpPortRegistrator PASSED 200 | ``` 201 | 202 | ###### Sample output for failing test: 203 | ``` 204 | org.bitsofinfo.hazelcast.discovery.etcd.TestDoNothingRegistrator > testDoNothingRegistrator STARTED 205 | 206 | org.bitsofinfo.hazelcast.discovery.etcd.TestDoNothingRegistrator > testDoNothingRegistrator FAILED 207 | java.lang.AssertionError at TestDoNothingRegistrator.java:85 208 | ``` 209 | 210 | To run individual unit-test, use the `test.single` argument to provide the unit-test you would like to run. The command below runs the unit test for `TestDoNothingRegistrator` 211 | 212 | ``` 213 | $ ./gradlew test -Dtest.single=TestDoNothingRegistrator 214 | ``` 215 | 216 | ##### Note on running `TestDoNothingRegistrator` unit-test 217 | The `TestDoNothingRegistrator` unit-test should be run separately using the `test.single` argument as demonstrated above as it requires you to register a service with your local etcd with 5 nodes/instances. Please **CAREFULLY READ** the comments in `TestDoNothingRegistrator.java` to see how this test should be run. 218 | 219 | 220 | ## Related info 221 | 222 | * https://github.com/coreos/etcd 223 | * https://github.com/jurmous/etcd4j 224 | * http://docs.hazelcast.org/docs/3.6/manual/html-single/index.html#discovery-spi 225 | * **Consul** version of this: https://github.com/bitsofinfo/hazelcast-consul-discovery-spi 226 | 227 | ## Notes 228 | 229 | ### Containerization (Docker) notes 230 | 231 | This library may also be helpful to you: [docker-discovery-registrator-consul](https://github.com/bitsofinfo/docker-discovery-registrator-consul) 232 | 233 | One of the main drivers for coding this module was for Hazelcast applications that were deployed as Docker containers 234 | that would need to automatically register themselves with Etcd for higher level cluster orchestration of the cluster. 235 | 236 | If you are deploying your Hazelcast application as a Docker container, one helpful tip is that you will want to avoid hardwired 237 | configuration in the hazelcast XML config, but rather have your Docker container take startup arguments that would be translated 238 | to `-D` system properties on startup. Convienently Hazelcast can consume these JVM system properties and replace variable placeholders in the XML config. See this documentation for examples: [http://docs.hazelcast.org/docs/3.6/manual/html-single/index.html#using-variables](http://docs.hazelcast.org/docs/3.6/manual/html-single/index.html#using-variables) 239 | 240 | Specifically when using this discovery strategy and Docker, it may be useful for you to use the [ExplicitIpPortRegistrator](src/main/java/org/bitsofinfo/hazelcast/discovery/etcd/ExplicitIpPortRegistrator.java) `EtcdRegistrator` **instead** of the *LocalDiscoveryNodeRegistrator* as the latter relies on hazelcast to determine its IP/PORT and this may end up being the local container IP, and not the Docker host IP, leading to a situation where a unreachable IP/PORT combination is published to Etcd. 241 | 242 | **Example:** excerpt from [explicitIpPortRegistrator-example.xml](src/main/resources/explicitIpPortRegistrator-example.xml) 243 | 244 | Start your hazelcast app such as with the below, this would assume that hazelcast is actually reachable via this configuration 245 | via your Docker host and the port mappings that were specified on `docker run`. (i.e. the IP below would be your docker host/port that is mapped to the actual hazelcast app container and port it exposes for hazelcast). 246 | 247 | This library may also be helpful to you: [docker-discovery-registrator-consul](https://github.com/bitsofinfo/docker-discovery-registrator-consul) 248 | 249 | See this [Docker issue for related info](https://github.com/docker/docker/issues/3778) on detecting mapped ports/ip from **within** a container 250 | 251 | `java -jar myHzApp.jar -DregisterWithIpAddress= -DregisterWithPort= .... ` 252 | 253 | ``` 254 | 260 | ``` 261 | -------------------------------------------------------------------------------- /build.gradle: -------------------------------------------------------------------------------- 1 | buildscript { 2 | repositories { 3 | mavenCentral() 4 | } 5 | } 6 | 7 | plugins { 8 | id "com.jfrog.bintray" version "1.5" 9 | } 10 | 11 | group = 'org.bitsofinfo' 12 | 13 | allprojects { 14 | repositories { 15 | jcenter() 16 | } 17 | apply plugin: 'maven' 18 | apply plugin: 'maven-publish' 19 | apply plugin: 'java' 20 | } 21 | 22 | sourceCompatibility = 1.7 23 | targetCompatibility = 1.7 24 | 25 | dependencies { 26 | 27 | compile group: 'com.hazelcast', name: 'hazelcast', version:'[3.6,3.12]' 28 | compile group: 'org.mousio', name: 'etcd4j', version:'2.9.0' 29 | compile group: 'com.google.code.gson', name: 'gson', version:'2.4' 30 | compile 'commons-io:commons-io:2.4' 31 | compile group: 'org.bouncycastle', name: 'bcpkix-jdk15on', version: '1.60' 32 | compile group: 'org.bouncycastle', name: 'bcprov-jdk15on', version: '1.60' 33 | 34 | testCompile 'junit:junit:4.12' 35 | } 36 | 37 | bintray { 38 | user = project.hasProperty('bintrayUser') ? project.property('bintrayUser') : System.getenv('bintrayUser') 39 | key = project.hasProperty('bintrayApiKey') ? project.property('bintrayApiKey') : System.getenv('bintrayApiKey') 40 | publications = ['hazelcastEtcdDiscoverySpi'] 41 | pkg { 42 | repo = 'maven' 43 | name = 'hazelcast-etcd-discovery-spi' 44 | licenses = ['Apache-2.0'] 45 | vcsUrl = 'https://github.com/bitsofinfo/hazelcast-etcd-discovery-spi' 46 | publicDownloadNumbers = true 47 | version { 48 | name = project.property('version') 49 | desc = project.property('version') + " : " + project.property('description') 50 | released = new Date() 51 | vcsTag = project.property('version') 52 | } 53 | } 54 | } 55 | 56 | publishing { 57 | publications { 58 | hazelcastEtcdDiscoverySpi(MavenPublication) { 59 | from components.java 60 | 61 | groupId project.property('group') 62 | artifactId 'hazelcast-etcd-discovery-spi' 63 | version project.property('version') 64 | 65 | artifact sourcesJar 66 | artifact javadocJar 67 | 68 | pom.withXml { 69 | asNode().appendNode('name', project.property('group')+":hazelcast-etcd-discovery-spi") 70 | asNode().appendNode('description', project.property('description')) 71 | asNode().appendNode('url', "https://github.com/bitsofinfo/hazelcast-etcd-discovery-spi") 72 | asNode().appendNode('packaging', "jar") 73 | asNode().appendNode('licenses').appendNode('license') 74 | .appendNode('name', "The Apache License, Version 2.0").parent() 75 | .appendNode('url', "http://www.apache.org/licenses/LICENSE-2.0.txt") 76 | asNode().appendNode('developers').appendNode('developer') 77 | .appendNode('id', "bitsofinfo").parent() 78 | .appendNode('name', "bitsofinfo").parent() 79 | .appendNode('email', "bitsofinfo.g@gmail.com").parent() 80 | .appendNode('organization',"bitsofinfo").parent() 81 | .appendNode('organizationUrl','https://github.com/bitsofinfo') 82 | asNode().appendNode('scm') 83 | .appendNode('connection', "scm:git:https://github.com/bitsofinfo/hazelcast-etcd-discovery-spi.git").parent() 84 | .appendNode('developerConnection', "scm:git:https://github.com/bitsofinfo/hazelcast-etcd-discovery-spi.git").parent() 85 | .appendNode('url', "https://github.com/bitsofinfo/hazelcast-etcd-discovery-spi") 86 | } 87 | 88 | } 89 | } 90 | } 91 | 92 | task sourcesJar(type: Jar, dependsOn: classes) { 93 | classifier = 'sources' 94 | from sourceSets.main.allSource 95 | } 96 | 97 | 98 | task javadocJar(type: Jar, dependsOn: 'javadoc') { 99 | classifier = 'javadoc' 100 | from javadoc.destinationDir 101 | } 102 | 103 | artifacts { 104 | archives sourcesJar 105 | archives javadocJar 106 | } 107 | 108 | 109 | task runTests(type: Test) { 110 | description 'Runs unit tests for all tests except TestDoNothingRegistrator.' 111 | 112 | //Always run tests even when up-to-date 113 | outputs.upToDateWhen { 114 | false 115 | } 116 | 117 | //Exclude TestDoNothingRegistrator test because it requires special setup 118 | exclude "**/TestDoNothingRegistrator.class" 119 | } 120 | 121 | runTests { 122 | testLogging { 123 | // Show that tests are run in the command-line output 124 | events 'started', 'passed' 125 | } 126 | } 127 | -------------------------------------------------------------------------------- /docs/diag.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/bitsofinfo/hazelcast-etcd-discovery-spi/574b24d451a7272345ff0a12ed77d2f69ce0884a/docs/diag.png -------------------------------------------------------------------------------- /gradle.properties: -------------------------------------------------------------------------------- 1 | version=1.0-RC4-20210205 2 | description=hazelcast-etcd-discovery-spi - Etcd based discovery strategy SPI for Hazelcast enabled applications 3 | -------------------------------------------------------------------------------- /gradle/wrapper/gradle-wrapper.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/bitsofinfo/hazelcast-etcd-discovery-spi/574b24d451a7272345ff0a12ed77d2f69ce0884a/gradle/wrapper/gradle-wrapper.jar -------------------------------------------------------------------------------- /gradle/wrapper/gradle-wrapper.properties: -------------------------------------------------------------------------------- 1 | #Mon Jul 13 10:02:35 EDT 2015 2 | distributionBase=GRADLE_USER_HOME 3 | distributionPath=wrapper/dists 4 | zipStoreBase=GRADLE_USER_HOME 5 | zipStorePath=wrapper/dists 6 | distributionUrl=https\://services.gradle.org/distributions/gradle-2.5-bin.zip 7 | -------------------------------------------------------------------------------- /gradlew: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | ############################################################################## 4 | ## 5 | ## Gradle start up script for UN*X 6 | ## 7 | ############################################################################## 8 | 9 | # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. 10 | DEFAULT_JVM_OPTS="" 11 | 12 | APP_NAME="Gradle" 13 | APP_BASE_NAME=`basename "$0"` 14 | 15 | # Use the maximum available, or set MAX_FD != -1 to use that value. 16 | MAX_FD="maximum" 17 | 18 | warn ( ) { 19 | echo "$*" 20 | } 21 | 22 | die ( ) { 23 | echo 24 | echo "$*" 25 | echo 26 | exit 1 27 | } 28 | 29 | # OS specific support (must be 'true' or 'false'). 30 | cygwin=false 31 | msys=false 32 | darwin=false 33 | case "`uname`" in 34 | CYGWIN* ) 35 | cygwin=true 36 | ;; 37 | Darwin* ) 38 | darwin=true 39 | ;; 40 | MINGW* ) 41 | msys=true 42 | ;; 43 | esac 44 | 45 | # For Cygwin, ensure paths are in UNIX format before anything is touched. 46 | if $cygwin ; then 47 | [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"` 48 | fi 49 | 50 | # Attempt to set APP_HOME 51 | # Resolve links: $0 may be a link 52 | PRG="$0" 53 | # Need this for relative symlinks. 54 | while [ -h "$PRG" ] ; do 55 | ls=`ls -ld "$PRG"` 56 | link=`expr "$ls" : '.*-> \(.*\)$'` 57 | if expr "$link" : '/.*' > /dev/null; then 58 | PRG="$link" 59 | else 60 | PRG=`dirname "$PRG"`"/$link" 61 | fi 62 | done 63 | SAVED="`pwd`" 64 | cd "`dirname \"$PRG\"`/" >&- 65 | APP_HOME="`pwd -P`" 66 | cd "$SAVED" >&- 67 | 68 | CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar 69 | 70 | # Determine the Java command to use to start the JVM. 71 | if [ -n "$JAVA_HOME" ] ; then 72 | if [ -x "$JAVA_HOME/jre/sh/java" ] ; then 73 | # IBM's JDK on AIX uses strange locations for the executables 74 | JAVACMD="$JAVA_HOME/jre/sh/java" 75 | else 76 | JAVACMD="$JAVA_HOME/bin/java" 77 | fi 78 | if [ ! -x "$JAVACMD" ] ; then 79 | die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME 80 | 81 | Please set the JAVA_HOME variable in your environment to match the 82 | location of your Java installation." 83 | fi 84 | else 85 | JAVACMD="java" 86 | which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 87 | 88 | Please set the JAVA_HOME variable in your environment to match the 89 | location of your Java installation." 90 | fi 91 | 92 | # Increase the maximum file descriptors if we can. 93 | if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then 94 | MAX_FD_LIMIT=`ulimit -H -n` 95 | if [ $? -eq 0 ] ; then 96 | if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then 97 | MAX_FD="$MAX_FD_LIMIT" 98 | fi 99 | ulimit -n $MAX_FD 100 | if [ $? -ne 0 ] ; then 101 | warn "Could not set maximum file descriptor limit: $MAX_FD" 102 | fi 103 | else 104 | warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" 105 | fi 106 | fi 107 | 108 | # For Darwin, add options to specify how the application appears in the dock 109 | if $darwin; then 110 | GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" 111 | fi 112 | 113 | # For Cygwin, switch paths to Windows format before running java 114 | if $cygwin ; then 115 | APP_HOME=`cygpath --path --mixed "$APP_HOME"` 116 | CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` 117 | 118 | # We build the pattern for arguments to be converted via cygpath 119 | ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` 120 | SEP="" 121 | for dir in $ROOTDIRSRAW ; do 122 | ROOTDIRS="$ROOTDIRS$SEP$dir" 123 | SEP="|" 124 | done 125 | OURCYGPATTERN="(^($ROOTDIRS))" 126 | # Add a user-defined pattern to the cygpath arguments 127 | if [ "$GRADLE_CYGPATTERN" != "" ] ; then 128 | OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" 129 | fi 130 | # Now convert the arguments - kludge to limit ourselves to /bin/sh 131 | i=0 132 | for arg in "$@" ; do 133 | CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` 134 | CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option 135 | 136 | if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition 137 | eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` 138 | else 139 | eval `echo args$i`="\"$arg\"" 140 | fi 141 | i=$((i+1)) 142 | done 143 | case $i in 144 | (0) set -- ;; 145 | (1) set -- "$args0" ;; 146 | (2) set -- "$args0" "$args1" ;; 147 | (3) set -- "$args0" "$args1" "$args2" ;; 148 | (4) set -- "$args0" "$args1" "$args2" "$args3" ;; 149 | (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; 150 | (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; 151 | (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; 152 | (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; 153 | (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; 154 | esac 155 | fi 156 | 157 | # Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules 158 | function splitJvmOpts() { 159 | JVM_OPTS=("$@") 160 | } 161 | eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS 162 | JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME" 163 | 164 | exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@" 165 | -------------------------------------------------------------------------------- /gradlew.bat: -------------------------------------------------------------------------------- 1 | @if "%DEBUG%" == "" @echo off 2 | @rem ########################################################################## 3 | @rem 4 | @rem Gradle startup script for Windows 5 | @rem 6 | @rem ########################################################################## 7 | 8 | @rem Set local scope for the variables with windows NT shell 9 | if "%OS%"=="Windows_NT" setlocal 10 | 11 | @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. 12 | set DEFAULT_JVM_OPTS= 13 | 14 | set DIRNAME=%~dp0 15 | if "%DIRNAME%" == "" set DIRNAME=. 16 | set APP_BASE_NAME=%~n0 17 | set APP_HOME=%DIRNAME% 18 | 19 | @rem Find java.exe 20 | if defined JAVA_HOME goto findJavaFromJavaHome 21 | 22 | set JAVA_EXE=java.exe 23 | %JAVA_EXE% -version >NUL 2>&1 24 | if "%ERRORLEVEL%" == "0" goto init 25 | 26 | echo. 27 | echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 28 | echo. 29 | echo Please set the JAVA_HOME variable in your environment to match the 30 | echo location of your Java installation. 31 | 32 | goto fail 33 | 34 | :findJavaFromJavaHome 35 | set JAVA_HOME=%JAVA_HOME:"=% 36 | set JAVA_EXE=%JAVA_HOME%/bin/java.exe 37 | 38 | if exist "%JAVA_EXE%" goto init 39 | 40 | echo. 41 | echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 42 | echo. 43 | echo Please set the JAVA_HOME variable in your environment to match the 44 | echo location of your Java installation. 45 | 46 | goto fail 47 | 48 | :init 49 | @rem Get command-line arguments, handling Windowz variants 50 | 51 | if not "%OS%" == "Windows_NT" goto win9xME_args 52 | if "%@eval[2+2]" == "4" goto 4NT_args 53 | 54 | :win9xME_args 55 | @rem Slurp the command line arguments. 56 | set CMD_LINE_ARGS= 57 | set _SKIP=2 58 | 59 | :win9xME_args_slurp 60 | if "x%~1" == "x" goto execute 61 | 62 | set CMD_LINE_ARGS=%* 63 | goto execute 64 | 65 | :4NT_args 66 | @rem Get arguments from the 4NT Shell from JP Software 67 | set CMD_LINE_ARGS=%$ 68 | 69 | :execute 70 | @rem Setup the command line 71 | 72 | set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar 73 | 74 | @rem Execute Gradle 75 | "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS% 76 | 77 | :end 78 | @rem End local scope for the variables with windows NT shell 79 | if "%ERRORLEVEL%"=="0" goto mainEnd 80 | 81 | :fail 82 | rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of 83 | rem the _cmd.exe /c_ return code! 84 | if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 85 | exit /b 1 86 | 87 | :mainEnd 88 | if "%OS%"=="Windows_NT" endlocal 89 | 90 | :omega 91 | -------------------------------------------------------------------------------- /src/main/java/org/bitsofinfo/hazelcast/discovery/etcd/BaseRegistrator.java: -------------------------------------------------------------------------------- 1 | package org.bitsofinfo.hazelcast.discovery.etcd; 2 | 3 | import java.net.URI; 4 | import java.util.ArrayList; 5 | import java.util.List; 6 | import java.util.Map; 7 | 8 | import com.google.gson.Gson; 9 | import com.google.gson.GsonBuilder; 10 | import com.hazelcast.logging.ILogger; 11 | import com.hazelcast.nio.Address; 12 | import com.hazelcast.spi.discovery.DiscoveryNode; 13 | 14 | import mousio.etcd4j.EtcdClient; 15 | import mousio.etcd4j.responses.EtcdKeysResponse; 16 | 17 | /** 18 | * Use derivatives of this EtcdRegistrator if you want auto-registration 19 | * of this hazelcast instance in etcd under the key-path 20 | * 21 | * /[etcd-service-name]/[hz-instance-id (generated)] = 22 | * { ip:xx.xx.xx.xx, hostname:my.host, port: xx, ...} 23 | * 24 | * The IP/PORT that it registers with is generally dictated by classes 25 | * that derive from this class and override the determineMyLocalAddress() 26 | * method. 27 | * 28 | * It will also de-register the service if invoked to do so. 29 | * 30 | * Common custom options (specified as JSON value for the 'etcd-registrator-config') 31 | * which are available to all derivative classes 32 | * 33 | * - None at this time 34 | * 35 | * @author bitsofinfo 36 | * 37 | */ 38 | public abstract class BaseRegistrator implements EtcdRegistrator { 39 | 40 | protected ILogger logger = null; 41 | protected Address myLocalAddress = null; 42 | protected String etcdUsername = null; 43 | protected String etcdPassword = null; 44 | protected String etcdServiceName = null; 45 | protected String etcdUriStrings = null; 46 | protected List etcdUris = new ArrayList(); 47 | 48 | private String myServiceId = null; 49 | private String myEtcdKey = null; 50 | 51 | protected abstract Address determineMyLocalAddress(DiscoveryNode localDiscoveryNode, 52 | Map registratorConfig) throws Exception; 53 | 54 | @Override 55 | public void init(List etcdUris, 56 | String etcdUsername, 57 | String etcdPassword, 58 | String etcdServiceName, 59 | DiscoveryNode localDiscoveryNode, 60 | Map registratorConfig, 61 | ILogger logger) throws Exception { 62 | 63 | this.logger = logger; 64 | this.etcdUsername = etcdUsername; 65 | this.etcdPassword = etcdPassword; 66 | this.etcdServiceName = etcdServiceName; 67 | this.etcdUris = etcdUris; 68 | 69 | try { 70 | /** 71 | * Determine my local address 72 | */ 73 | this.myLocalAddress = determineMyLocalAddress(localDiscoveryNode, registratorConfig); 74 | logger.info("Determined local DiscoveryNode address to use: " + myLocalAddress); 75 | 76 | } catch(Exception e) { 77 | String msg = "Unexpected error in configuring LocalDiscoveryNodeRegistration: " + e.getMessage(); 78 | logger.severe(msg,e); 79 | throw new Exception(msg,e); 80 | } 81 | 82 | } 83 | 84 | @Override 85 | public String getMyServiceId() { 86 | return this.myServiceId; 87 | } 88 | 89 | @Override 90 | public void register() throws Exception { 91 | 92 | EtcdClient etcdClient = null; 93 | 94 | try { 95 | 96 | // create our client 97 | etcdClient = EtcdDiscoveryStrategy.getEtcdClient(etcdUris, etcdUsername, etcdPassword); 98 | 99 | // generate service id 100 | this.myServiceId = this.etcdServiceName + "-" + 101 | this.myLocalAddress.getInetAddress().getHostAddress() +"-" + 102 | this.myLocalAddress.getHost() + "-" + 103 | this.myLocalAddress.getPort(); 104 | 105 | // etcd key 106 | this.myEtcdKey = "/"+ this.etcdServiceName + "/" + this.myServiceId; 107 | 108 | // our value object 109 | EtcdHazelcastNode node = new EtcdHazelcastNode(this.myLocalAddress.getInetAddress().getHostAddress(), 110 | this.myLocalAddress.getPort(), 111 | this.myLocalAddress.getHost()); 112 | 113 | // put it 114 | EtcdKeysResponse response = etcdClient.put(this.myEtcdKey, 115 | new GsonBuilder().setDateFormat(EtcdDiscoveryStrategy.DATE_PATTERN).create().toJson(node)).send().get(); 116 | 117 | this.logger.info("Registered with Etcd["+etcdUriStrings+"] response=" + response.toString() + ", key: " + this.myEtcdKey); 118 | 119 | } catch(Exception e) { 120 | String msg = "Unexpected error in register(serviceId:"+myServiceId+"): " + e.getMessage(); 121 | logger.severe(msg,e); 122 | throw new Exception(msg,e); 123 | 124 | } finally { 125 | try { etcdClient.close(); } catch(Exception ignore){} 126 | } 127 | } 128 | 129 | @Override 130 | public void deregister() throws Exception { 131 | EtcdClient etcdClient = null; 132 | 133 | try { 134 | // create our client 135 | etcdClient = EtcdDiscoveryStrategy.getEtcdClient(etcdUris, etcdUsername, etcdPassword); 136 | 137 | // delete 138 | etcdClient.delete(this.myEtcdKey).send().get(); 139 | 140 | } catch(Exception e) { 141 | String msg = "Unexpected error in etcdClient.delete(key:"+this.myEtcdKey+"): " + e.getMessage(); 142 | logger.severe(msg,e); 143 | throw new Exception(msg,e); 144 | 145 | } finally { 146 | try { etcdClient.close(); } catch(Exception ignore){} 147 | } 148 | } 149 | 150 | 151 | } 152 | -------------------------------------------------------------------------------- /src/main/java/org/bitsofinfo/hazelcast/discovery/etcd/DoNothingRegistrator.java: -------------------------------------------------------------------------------- 1 | package org.bitsofinfo.hazelcast.discovery.etcd; 2 | 3 | import java.net.URI; 4 | import java.util.List; 5 | import java.util.Map; 6 | 7 | import com.hazelcast.logging.ILogger; 8 | import com.hazelcast.spi.discovery.DiscoveryNode; 9 | 10 | /** 11 | * Use this EtcdRegistrator if you manage the registration 12 | * of your hazelcast nodes manually/externally via a local 13 | * Etcd agent or other means. No registration/deregistration 14 | * will occur if you use this implementation 15 | * 16 | * @author bitsofinfo 17 | * 18 | */ 19 | public class DoNothingRegistrator implements EtcdRegistrator { 20 | 21 | @Override 22 | public String getMyServiceId() { 23 | return null; 24 | } 25 | 26 | @Override 27 | public void init(List etcdUris, String etcdUsername, String etcdPassword, String etcdServiceName, DiscoveryNode localDiscoveryNode, 28 | Map registratorConfig, ILogger logger) { 29 | 30 | } 31 | 32 | @Override 33 | public void register() throws Exception { 34 | } 35 | 36 | @Override 37 | public void deregister() throws Exception { 38 | } 39 | 40 | } 41 | -------------------------------------------------------------------------------- /src/main/java/org/bitsofinfo/hazelcast/discovery/etcd/EtcdDiscoveryConfiguration.java: -------------------------------------------------------------------------------- 1 | package org.bitsofinfo.hazelcast.discovery.etcd; 2 | 3 | import com.hazelcast.config.properties.PropertyDefinition; 4 | import com.hazelcast.config.properties.PropertyTypeConverter; 5 | import com.hazelcast.config.properties.SimplePropertyDefinition; 6 | 7 | /** 8 | * Defines constants for our supported Properties 9 | * 10 | * @author bitsofinfo 11 | * 12 | */ 13 | public class EtcdDiscoveryConfiguration { 14 | 15 | public static final PropertyDefinition ETCD_URIS = 16 | new SimplePropertyDefinition("etcd-uris", PropertyTypeConverter.STRING); 17 | 18 | public static final PropertyDefinition ETCD_USERNAME = 19 | new SimplePropertyDefinition("etcd-username", true, PropertyTypeConverter.STRING); 20 | 21 | public static final PropertyDefinition ETCD_PASSWORD = 22 | new SimplePropertyDefinition("etcd-password", true, PropertyTypeConverter.STRING); 23 | 24 | public static final PropertyDefinition ETCD_SERVICE_NAME = 25 | new SimplePropertyDefinition("etcd-service-name", PropertyTypeConverter.STRING); 26 | 27 | public static final PropertyDefinition ETCD_REGISTRATOR = 28 | new SimplePropertyDefinition("etcd-registrator", true, PropertyTypeConverter.STRING); 29 | 30 | public static final PropertyDefinition ETCD_REGISTRATOR_CONFIG = 31 | new SimplePropertyDefinition("etcd-registrator-config", true, PropertyTypeConverter.STRING); 32 | 33 | public static final PropertyDefinition ETCD_DISCOVERY_DELAY_MS = 34 | new SimplePropertyDefinition("etcd-discovery-delay-ms", PropertyTypeConverter.INTEGER); 35 | 36 | public static final PropertyDefinition ETCD_CLIENT_CERT_LOCATION = 37 | new SimplePropertyDefinition("etcd-client-cert-location", true, PropertyTypeConverter.STRING); 38 | 39 | public static final PropertyDefinition ETCD_CLIENT_KEY_LOCATION = 40 | new SimplePropertyDefinition("etcd-client-key-location", true, PropertyTypeConverter.STRING); 41 | 42 | public static final PropertyDefinition ETCD_TRUSTED_CERT_LOCATION = 43 | new SimplePropertyDefinition("etcd-trusted-cert-location", true, PropertyTypeConverter.STRING); 44 | 45 | 46 | } 47 | -------------------------------------------------------------------------------- /src/main/java/org/bitsofinfo/hazelcast/discovery/etcd/EtcdDiscoveryStrategy.java: -------------------------------------------------------------------------------- 1 | package org.bitsofinfo.hazelcast.discovery.etcd; 2 | 3 | import java.io.ByteArrayInputStream; 4 | import java.io.FileInputStream; 5 | import java.io.IOException; 6 | import java.io.StringReader; 7 | import java.lang.reflect.Type; 8 | import java.net.URI; 9 | import java.security.GeneralSecurityException; 10 | import java.security.KeyFactory; 11 | import java.security.KeyPair; 12 | import java.security.KeyStore; 13 | import java.security.PrivateKey; 14 | import java.security.Security; 15 | import java.security.cert.Certificate; 16 | import java.security.cert.CertificateFactory; 17 | import java.security.spec.PKCS8EncodedKeySpec; 18 | import java.util.ArrayList; 19 | import java.util.Base64; 20 | import java.util.Collections; 21 | import java.util.List; 22 | import java.util.Map; 23 | import java.util.concurrent.TimeUnit; 24 | 25 | import javax.naming.ConfigurationException; 26 | import javax.net.ssl.KeyManagerFactory; 27 | import javax.net.ssl.TrustManagerFactory; 28 | import javax.xml.bind.DatatypeConverter; 29 | 30 | import org.apache.commons.io.IOUtils; 31 | import org.bouncycastle.jce.provider.BouncyCastleProvider; 32 | import org.bouncycastle.openssl.PEMKeyPair; 33 | import org.bouncycastle.openssl.PEMParser; 34 | import org.bouncycastle.openssl.jcajce.JcaPEMKeyConverter; 35 | 36 | import com.google.gson.Gson; 37 | import com.google.gson.GsonBuilder; 38 | import com.google.gson.reflect.TypeToken; 39 | import com.hazelcast.logging.ILogger; 40 | import com.hazelcast.nio.Address; 41 | import com.hazelcast.spi.discovery.AbstractDiscoveryStrategy; 42 | import com.hazelcast.spi.discovery.DiscoveryNode; 43 | import com.hazelcast.spi.discovery.SimpleDiscoveryNode; 44 | 45 | import io.netty.handler.ssl.SslContext; 46 | import io.netty.handler.ssl.SslContextBuilder; 47 | import mousio.etcd4j.EtcdClient; 48 | import mousio.etcd4j.responses.EtcdKeysResponse; 49 | import mousio.etcd4j.responses.EtcdKeysResponse.EtcdNode; 50 | 51 | /** 52 | * DiscoveryStrategy for Etcd 53 | * 54 | * @author bitsofinfo 55 | * 56 | */ 57 | public class EtcdDiscoveryStrategy extends AbstractDiscoveryStrategy implements Runnable { 58 | 59 | public static final String DATE_PATTERN = "yyyy.MM.dd HH:mm:ss.SSS Z"; 60 | 61 | private static final String TEMPORARY_KEY_PASSWORD = "changeit"; 62 | 63 | //custom TLS certs and key 64 | static private String trustedCertsLocation; 65 | static private String clientKeyLocation; 66 | static private String clientCertLocation; 67 | 68 | // how we connect to etcd 69 | private String etcdUrisString; 70 | private List etcdUris = new ArrayList(); 71 | private String etcdUsername; 72 | private String etcdPassword; 73 | 74 | // service name we will key under 75 | private String etcdServiceName = null; 76 | 77 | // How we register with Etcd 78 | private EtcdRegistrator registrator = null; 79 | 80 | static { 81 | Security.addProvider(new BouncyCastleProvider()); 82 | } 83 | 84 | 85 | /** 86 | * Constructor 87 | * 88 | * @param localDiscoveryNode 89 | * @param logger 90 | * @param properties 91 | */ 92 | public EtcdDiscoveryStrategy(DiscoveryNode localDiscoveryNode, ILogger logger, Map properties ) { 93 | 94 | super( logger, properties ); 95 | 96 | // get basic properites for the strategy 97 | this.etcdUrisString = getOrDefault("etcd-uris", EtcdDiscoveryConfiguration.ETCD_URIS, "http://localhost:4001"); 98 | this.etcdUsername = getOrDefault("etcd-username", EtcdDiscoveryConfiguration.ETCD_USERNAME, null); 99 | this.etcdPassword = getOrDefault("etcd-password", EtcdDiscoveryConfiguration.ETCD_PASSWORD, null); 100 | this.etcdServiceName = getOrDefault("etcd-service-name", EtcdDiscoveryConfiguration.ETCD_SERVICE_NAME, ""); 101 | 102 | clientCertLocation = getOrDefault("etcd-client-cert-location", EtcdDiscoveryConfiguration.ETCD_CLIENT_CERT_LOCATION, ""); 103 | clientKeyLocation = getOrDefault("etcd-client-key-location", EtcdDiscoveryConfiguration.ETCD_CLIENT_KEY_LOCATION, ""); 104 | trustedCertsLocation = getOrDefault("etcd-trusted-cert-location", EtcdDiscoveryConfiguration.ETCD_TRUSTED_CERT_LOCATION, ""); 105 | 106 | long discoveryDelayMS = getOrDefault("etcd-discovery-delay-ms", EtcdDiscoveryConfiguration.ETCD_DISCOVERY_DELAY_MS, 30000); 107 | 108 | /** 109 | * Parse etcd URI strings 110 | */ 111 | for (String rawUri : etcdUrisString.split(",")) { 112 | try { 113 | etcdUris.add(URI.create(rawUri.trim())); 114 | } catch(Exception e) { 115 | logger.severe("Error parsing etcd-uris: " + rawUri + " " + e.getMessage(),e); 116 | } 117 | } 118 | 119 | 120 | // our EtcdRegistrator default is DoNothingRegistrator 121 | String registratorClassName = getOrDefault("etcd-registrator", 122 | EtcdDiscoveryConfiguration.ETCD_REGISTRATOR, 123 | DoNothingRegistrator.class.getCanonicalName()); 124 | 125 | // this is optional, custom properties to configure a registrator 126 | // @see the EtcdRegistrator for a description of supported options 127 | String registratorConfigJSON = getOrDefault("etcd-registrator-config", 128 | EtcdDiscoveryConfiguration.ETCD_REGISTRATOR_CONFIG, 129 | null); 130 | 131 | // if JSON config is present attempt to parse it into a map 132 | Map registratorConfig = null; 133 | if (registratorConfigJSON != null && !registratorConfigJSON.trim().isEmpty()) { 134 | try { 135 | Type type = new TypeToken>(){}.getType(); 136 | registratorConfig = new Gson().fromJson(registratorConfigJSON, type); 137 | 138 | } catch(Exception e) { 139 | logger.severe("Unexpected error parsing 'etcd-registrator-config' JSON: " + 140 | registratorConfigJSON + " error="+e.getMessage(),e); 141 | } 142 | } 143 | 144 | 145 | // Ok, now construct our registrator and register with Etcd 146 | try { 147 | registrator = (EtcdRegistrator)Class.forName(registratorClassName).newInstance(); 148 | 149 | logger.info("Using EtcdRegistrator: " + registratorClassName); 150 | 151 | registrator.init(etcdUris, etcdUsername, etcdPassword, etcdServiceName, localDiscoveryNode, registratorConfig, logger);; 152 | registrator.register(); 153 | 154 | } catch(Exception e) { 155 | logger.severe("Unexpected error attempting to init() EtcdRegistrator and register(): " +e.getMessage(),e); 156 | } 157 | 158 | // register our shutdown hook for deregisteration on shutdown... 159 | Thread shutdownThread = new Thread(this); 160 | Runtime.getRuntime().addShutdownHook(shutdownThread); 161 | 162 | // finally sleep a bit according to the configured discoveryDelayMS 163 | try { 164 | logger.info("Registered our instance w/ Etcd OK.. delaying Hazelcast discovery, sleeping: " + discoveryDelayMS + "ms"); 165 | Thread.sleep(discoveryDelayMS); 166 | } catch(Exception e) { 167 | logger.severe("Unexpected error sleeping prior to discovery: " + e.getMessage(),e); 168 | } 169 | 170 | } 171 | 172 | protected static EtcdClient getEtcdClient(List etcdUris, String username, String password) throws Exception { 173 | // build our clients 174 | 175 | if (etcdUris.iterator().next().toString().toLowerCase().indexOf("https") != -1) { 176 | SslContextBuilder builder = SslContextBuilder.forClient(); 177 | 178 | //create custom SSLContext when certs and key are provided, if not there this will return NULL 179 | KeyStore keyStore = readCertsAndCreateKeyStore(clientCertLocation, clientKeyLocation, trustedCertsLocation); 180 | 181 | if(keyStore != null) { 182 | KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm()); 183 | kmf.init(keyStore, TEMPORARY_KEY_PASSWORD.toCharArray()); 184 | TrustManagerFactory tmfactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm()); 185 | tmfactory.init(keyStore); 186 | 187 | builder.keyManager(kmf); 188 | builder.trustManager(tmfactory); 189 | } 190 | SslContext sslContext = builder.build(); 191 | return new EtcdClient(sslContext, username, password, etcdUris.toArray(new URI[]{})); 192 | } else { 193 | return new EtcdClient(username, password, etcdUris.toArray(new URI[]{})); 194 | } 195 | } 196 | 197 | @Override 198 | public Iterable discoverNodes() { 199 | 200 | List toReturn = new ArrayList(); 201 | 202 | EtcdClient etcdClient = null; 203 | 204 | try { 205 | etcdClient = getEtcdClient(this.etcdUris, this.etcdUsername, this.etcdPassword); 206 | 207 | Gson gson = new GsonBuilder().setDateFormat(DATE_PATTERN).create(); 208 | 209 | // discover all nodes under key /[etcdServiceName 210 | EtcdKeysResponse dirResp = etcdClient.getDir(this.etcdServiceName) 211 | .timeout(10, TimeUnit.SECONDS).recursive().send().get(); 212 | 213 | if(dirResp.node != null) { 214 | for (EtcdNode node : dirResp.node.nodes) { 215 | if (node.value != null && !node.value.trim().isEmpty()) { 216 | try { 217 | EtcdHazelcastNode etcdNode = (EtcdHazelcastNode)gson.fromJson(node.value, EtcdHazelcastNode.class); 218 | toReturn.add(new SimpleDiscoveryNode(new Address(etcdNode.ip,etcdNode.port))); 219 | 220 | } catch(Exception e) { 221 | getLogger().severe("Skipping node... error parsing etcd node["+node.key+"] " 222 | + "value: " + node.value + " to EtcdHazelcastNode..." + e.getMessage(),e); 223 | } 224 | } 225 | } 226 | } 227 | 228 | } catch(Exception e) { 229 | getLogger().severe("discoverNodes() unexpected error: " + e.getMessage(),e); 230 | 231 | } finally { 232 | try { etcdClient.close(); } catch(Exception ignore){} 233 | } 234 | 235 | return toReturn; 236 | } 237 | 238 | @Override 239 | public void run() { 240 | try { 241 | if (registrator != null) { 242 | getLogger().info("Deregistering myself from Etcd: " + this.registrator.getMyServiceId()); 243 | registrator.deregister(); 244 | } 245 | } catch(Throwable e) { 246 | this.getLogger().severe("Unexpected error in EtcdRegistrator.deregister(): " + e.getMessage(),e); 247 | } 248 | 249 | } 250 | 251 | private static KeyStore readCertsAndCreateKeyStore(String clientCertLocation, String clientKeyLocation, String trustedCertsLocation) throws ConfigurationException { 252 | 253 | if((clientCertLocation == null || clientCertLocation.isEmpty()) && (clientKeyLocation == null || clientKeyLocation.isEmpty()) && 254 | trustedCertsLocation == null || trustedCertsLocation.isEmpty()) { 255 | return null; 256 | } 257 | 258 | String strTrustedCertsData = null; 259 | String strClientKeyData = null; 260 | String strClientCertData = null; 261 | try (FileInputStream fisTrust = new FileInputStream(trustedCertsLocation)) { 262 | strTrustedCertsData = new String(IOUtils.toByteArray(fisTrust)); 263 | } catch (Exception e) { 264 | strTrustedCertsData = null; 265 | } 266 | 267 | try (FileInputStream fisKey = new FileInputStream(clientKeyLocation)) { 268 | strClientKeyData = new String(IOUtils.toByteArray(fisKey)); 269 | } catch (Exception e) { 270 | strClientKeyData = null; 271 | } 272 | 273 | try (FileInputStream fisCert = new FileInputStream(clientCertLocation)) { 274 | strClientCertData = new String(IOUtils.toByteArray(fisCert)); 275 | } catch (Exception e) { 276 | strClientCertData = null; 277 | } 278 | 279 | if (strClientCertData == null && strClientKeyData == null && strTrustedCertsData == null) { 280 | return null; // no SSL 281 | } 282 | 283 | return getKeyStore(strTrustedCertsData, strClientKeyData, strClientCertData); 284 | } 285 | 286 | private static KeyStore getKeyStore(String trustedCerts, String clientKey, String clientCert) 287 | throws ConfigurationException { 288 | try { 289 | 290 | KeyStore keyStore = KeyStore.getInstance("JKS"); 291 | keyStore.load(null, null); 292 | 293 | PrivateKey privateKey = loadPrivateKey(clientKey); 294 | 295 | if (trustedCerts == null) { 296 | if(clientCert != null) { 297 | //chained cert and trusted certs 298 | List chainedCerts = loadChainedCertificate(clientCert); 299 | if(chainedCerts.size() > 1) { 300 | for (int i = 1; i < chainedCerts.size(); i++) { 301 | keyStore.setCertificateEntry("ca-cert-" + i, chainedCerts.get(i)); 302 | } 303 | } 304 | keyStore.setCertificateEntry("client-cert", chainedCerts.get(0)); 305 | //private key 306 | if(privateKey != null) { 307 | keyStore.setKeyEntry("client-key", privateKey, TEMPORARY_KEY_PASSWORD.toCharArray(), 308 | new Certificate[] { chainedCerts.get(0) }); 309 | } 310 | } 311 | } else { 312 | //trusted certs 313 | if(trustedCerts != null) { 314 | List caCertificates = loadChainedCertificate(trustedCerts); 315 | for (int i = 0; i < caCertificates.size(); i++) { 316 | keyStore.setCertificateEntry("ca-cert-" + i, caCertificates.get(i)); 317 | } 318 | } 319 | //cert 320 | if(clientCert != null) { 321 | Certificate clientCertificate = loadCertificate(clientCert); 322 | keyStore.setCertificateEntry("client-cert", clientCertificate); 323 | 324 | //key 325 | if(privateKey != null) { 326 | keyStore.setKeyEntry("client-key", privateKey, TEMPORARY_KEY_PASSWORD.toCharArray(), 327 | new Certificate[] { clientCertificate }); 328 | } 329 | } 330 | } 331 | return keyStore; 332 | } catch (GeneralSecurityException | IOException e) { 333 | ConfigurationException ex = new ConfigurationException("Cannot build keystore"); 334 | ex.setRootCause(e); 335 | throw ex; 336 | } 337 | } 338 | 339 | 340 | private static List loadChainedCertificate(String clientCerts) throws GeneralSecurityException { 341 | 342 | if (clientCerts == null) { 343 | return null; 344 | } 345 | 346 | String beginDelimiter = "-----BEGIN CERTIFICATE-----"; 347 | String endDelimiter = "-----END CERTIFICATE-----"; 348 | CertificateFactory certificateFactory = CertificateFactory.getInstance("X509"); 349 | 350 | String[] tokens = clientCerts.split(beginDelimiter); 351 | 352 | List result = new ArrayList<>(); 353 | for (int i = 1; i < tokens.length; i++) { 354 | String[] tokens2 = tokens[i].split(endDelimiter); 355 | result.add(certificateFactory 356 | .generateCertificate(new ByteArrayInputStream(DatatypeConverter.parseBase64Binary(tokens2[0])))); 357 | 358 | } 359 | return result; 360 | } 361 | 362 | private static Certificate loadCertificate(String certificatePem) throws IOException, GeneralSecurityException { 363 | final byte[] content = parseDERFromPEM(certificatePem, "-----BEGIN CERTIFICATE-----", 364 | "-----END CERTIFICATE-----"); 365 | CertificateFactory certificateFactory = CertificateFactory.getInstance("X509"); 366 | return certificateFactory.generateCertificate(new ByteArrayInputStream(content)); 367 | } 368 | 369 | private static PrivateKey loadPrivateKey(String privateKeyPem) throws IOException, GeneralSecurityException { 370 | 371 | if(privateKeyPem == null || privateKeyPem.isEmpty()) { 372 | return null; 373 | } 374 | 375 | // PKCS#8 format 376 | final String PEM_PRIVATE_START = "-----BEGIN PRIVATE KEY-----"; 377 | final String PEM_PRIVATE_END = "-----END PRIVATE KEY-----"; 378 | 379 | // PKCS#1 format 380 | final String PEM_RSA_PRIVATE_START = "-----BEGIN RSA PRIVATE KEY-----"; 381 | // final String PEM_RSA_PRIVATE_END = "-----END RSA PRIVATE KEY-----"; 382 | 383 | if (privateKeyPem.contains(PEM_PRIVATE_START)) { // PKCS#8 format 384 | privateKeyPem = privateKeyPem.replace(PEM_PRIVATE_START, "").replace(PEM_PRIVATE_END, ""); 385 | privateKeyPem = privateKeyPem.replaceAll("\\s", ""); 386 | 387 | byte[] pkcs8EncodedKey = Base64.getDecoder().decode(privateKeyPem); 388 | 389 | KeyFactory factory = KeyFactory.getInstance("RSA"); 390 | return factory.generatePrivate(new PKCS8EncodedKeySpec(pkcs8EncodedKey)); 391 | } else if (privateKeyPem.contains(PEM_RSA_PRIVATE_START)) { // PKCS#1 format 392 | PEMParser pemParser = new PEMParser(new StringReader(privateKeyPem)); 393 | Object object = pemParser.readObject(); 394 | pemParser.close(); 395 | JcaPEMKeyConverter converter = new JcaPEMKeyConverter().setProvider("BC"); 396 | KeyPair kp = converter.getKeyPair((PEMKeyPair) object); 397 | 398 | return kp.getPrivate(); 399 | } 400 | 401 | throw new GeneralSecurityException("Not supported format of a private key"); 402 | } 403 | 404 | private static byte[] parseDERFromPEM(String pem, String beginDelimiter, String endDelimiter) { 405 | String[] tokens = pem.split(beginDelimiter); 406 | tokens = tokens[1].split(endDelimiter); 407 | return DatatypeConverter.parseBase64Binary(tokens[0]); 408 | } 409 | 410 | } 411 | -------------------------------------------------------------------------------- /src/main/java/org/bitsofinfo/hazelcast/discovery/etcd/EtcdDiscoveryStrategyFactory.java: -------------------------------------------------------------------------------- 1 | package org.bitsofinfo.hazelcast.discovery.etcd; 2 | 3 | import java.util.Arrays; 4 | import java.util.Collection; 5 | import java.util.Map; 6 | 7 | import com.hazelcast.config.properties.PropertyDefinition; 8 | import com.hazelcast.logging.ILogger; 9 | import com.hazelcast.spi.discovery.DiscoveryNode; 10 | import com.hazelcast.spi.discovery.DiscoveryStrategy; 11 | import com.hazelcast.spi.discovery.DiscoveryStrategyFactory; 12 | 13 | public class EtcdDiscoveryStrategyFactory implements DiscoveryStrategyFactory { 14 | 15 | private static final Collection PROPERTIES = 16 | Arrays.asList(new PropertyDefinition[]{ 17 | EtcdDiscoveryConfiguration.ETCD_URIS, 18 | EtcdDiscoveryConfiguration.ETCD_USERNAME, 19 | EtcdDiscoveryConfiguration.ETCD_PASSWORD, 20 | EtcdDiscoveryConfiguration.ETCD_SERVICE_NAME, 21 | EtcdDiscoveryConfiguration.ETCD_REGISTRATOR, 22 | EtcdDiscoveryConfiguration.ETCD_REGISTRATOR_CONFIG, 23 | EtcdDiscoveryConfiguration.ETCD_DISCOVERY_DELAY_MS, 24 | EtcdDiscoveryConfiguration.ETCD_CLIENT_CERT_LOCATION, 25 | EtcdDiscoveryConfiguration.ETCD_CLIENT_KEY_LOCATION, 26 | EtcdDiscoveryConfiguration.ETCD_TRUSTED_CERT_LOCATION 27 | }); 28 | 29 | public Class getDiscoveryStrategyType() { 30 | // Returns the actual class type of the DiscoveryStrategy 31 | // implementation, to match it against the configuration 32 | return EtcdDiscoveryStrategy.class; 33 | } 34 | 35 | public Collection getConfigurationProperties() { 36 | return PROPERTIES; 37 | } 38 | 39 | public DiscoveryStrategy newDiscoveryStrategy(DiscoveryNode discoveryNode, 40 | ILogger logger, 41 | Map properties ) { 42 | 43 | return new EtcdDiscoveryStrategy( discoveryNode, logger, properties ); 44 | } 45 | 46 | } 47 | -------------------------------------------------------------------------------- /src/main/java/org/bitsofinfo/hazelcast/discovery/etcd/EtcdHazelcastNode.java: -------------------------------------------------------------------------------- 1 | package org.bitsofinfo.hazelcast.discovery.etcd; 2 | 3 | import java.util.Date; 4 | 5 | public class EtcdHazelcastNode { 6 | 7 | public String ip; 8 | public Integer port; 9 | public String hostname; 10 | public Date registeredAt; 11 | 12 | public EtcdHazelcastNode(String ip, Integer port, String hostname) { 13 | super(); 14 | this.ip = ip; 15 | this.port = port; 16 | this.hostname = hostname; 17 | this.registeredAt = new Date(); 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /src/main/java/org/bitsofinfo/hazelcast/discovery/etcd/EtcdRegistrator.java: -------------------------------------------------------------------------------- 1 | package org.bitsofinfo.hazelcast.discovery.etcd; 2 | 3 | import java.net.URI; 4 | import java.util.List; 5 | import java.util.Map; 6 | 7 | import com.hazelcast.logging.ILogger; 8 | import com.hazelcast.spi.discovery.DiscoveryNode; 9 | 10 | /** 11 | * Defines an interface for an object who's responsibility 12 | * it is to register (and deregister) this hazelcast instance with Etcd. 13 | * 14 | * @author bitsofinfo 15 | * 16 | */ 17 | public interface EtcdRegistrator { 18 | 19 | /** 20 | * Return the service id as registered with Etcd 21 | * 22 | * @return 23 | */ 24 | public String getMyServiceId(); 25 | 26 | /** 27 | * Initialize the registrator 28 | * 29 | * @param etcUris 30 | * @param etcdUsername 31 | * @param etcdPassword 32 | * @param etcdServiceName 33 | * @param localDiscoveryNode 34 | * @param registratorConfig 35 | * @param logger 36 | * @throws Exception 37 | */ 38 | public void init(List etcUris, 39 | String etcdUsername, 40 | String etcdPassword, 41 | String etcdServiceName, 42 | DiscoveryNode localDiscoveryNode, 43 | Map registratorConfig, 44 | ILogger logger) throws Exception; 45 | 46 | /** 47 | * Register this hazelcast instance as a service node 48 | * with Etcd 49 | * 50 | * @throws Exception 51 | */ 52 | public void register() throws Exception; 53 | 54 | /** 55 | * Deregister this hazelcast instance as a service node 56 | * with Etcd 57 | * 58 | * @throws Exception 59 | */ 60 | public void deregister() throws Exception; 61 | 62 | } 63 | -------------------------------------------------------------------------------- /src/main/java/org/bitsofinfo/hazelcast/discovery/etcd/ExplicitIpPortRegistrator.java: -------------------------------------------------------------------------------- 1 | package org.bitsofinfo.hazelcast.discovery.etcd; 2 | 3 | import java.util.Map; 4 | 5 | import com.hazelcast.nio.Address; 6 | import com.hazelcast.spi.discovery.DiscoveryNode; 7 | 8 | /** 9 | * @see BaseRegistrator 10 | * 11 | * The IP/PORT that it registers with is whatever is specified by 12 | * in the `etcd-registrator-config` config options `ipAddress` and `port` 13 | * described below. 14 | * 15 | * Custom options (specified as JSON value for the 'etcd-registrator-config') 16 | * These are in ADDITION to those commonly defined in BaseRegistrator (base-class) 17 | * 18 | * 19 | * - registerWithIpAddress: the explicit IP address that this node should be registered 20 | * with Etcd as its ServiceAddress 21 | * 22 | * - registerWithPort: the explicit PORT that this node should be registered 23 | * with Etcd as its ServiceAddress 24 | * 25 | * @author bitsofinfo 26 | * 27 | */ 28 | public class ExplicitIpPortRegistrator extends BaseRegistrator { 29 | 30 | // properties that are supported in the JSON value for the 'etcd-registrator-config' config property 31 | // in ADDITION to those defined in BaseRegistrator 32 | public static final String CONFIG_PROP_REGISTER_WITH_IP_ADDRESS = "registerWithIpAddress"; 33 | public static final String CONFIG_PROP_REGISTER_WITH_PORT = "registerWithPort"; 34 | 35 | @Override 36 | public Address determineMyLocalAddress(DiscoveryNode localDiscoveryNode, Map registratorConfig) throws Exception { 37 | 38 | String registerWithIpAddress = (String)registratorConfig.get(CONFIG_PROP_REGISTER_WITH_IP_ADDRESS); 39 | Integer registerWithPort = ((Double)registratorConfig.get(CONFIG_PROP_REGISTER_WITH_PORT)).intValue(); 40 | 41 | logger.info("Registrator config properties: " + CONFIG_PROP_REGISTER_WITH_IP_ADDRESS +":"+registerWithIpAddress 42 | + " " + CONFIG_PROP_REGISTER_WITH_PORT + ":" + registerWithPort + 43 | ", will attempt to register with this IP/PORT..."); 44 | 45 | 46 | 47 | return new Address(registerWithIpAddress, registerWithPort); 48 | } 49 | } 50 | -------------------------------------------------------------------------------- /src/main/java/org/bitsofinfo/hazelcast/discovery/etcd/LocalDiscoveryNodeRegistrator.java: -------------------------------------------------------------------------------- 1 | package org.bitsofinfo.hazelcast.discovery.etcd; 2 | 3 | import java.util.Map; 4 | 5 | import com.hazelcast.nio.Address; 6 | import com.hazelcast.spi.discovery.DiscoveryNode; 7 | 8 | /** 9 | * @see BaseRegistrator 10 | * 11 | * The IP/PORT that it registers with is that auto detected/determined by Hazelcast 12 | * itself via Hazelcast's DiscoveryNode's Address that is passed to the EtcdDiscoveryStrategy 13 | * in its constructor. 14 | * 15 | * Custom options (specified as JSON value for the 'etcd-registrator-config') 16 | * These are in ADDITION to those commonly defined in BaseRegistrator (base-class) 17 | * 18 | * - preferPublicAddress (true|false) : use the public IP determined by 19 | * hazelcast (if not null) over the private IP 20 | * 21 | * @author bitsofinfo 22 | * 23 | */ 24 | public class LocalDiscoveryNodeRegistrator extends BaseRegistrator { 25 | 26 | // properties that are supported in the JSON value for the 'etcd-registrator-config' config property 27 | // in ADDITION to those defined in BaseRegistrator 28 | public static final String CONFIG_PROP_PREFER_PUBLIC_ADDRESS = "preferPublicAddress"; 29 | 30 | @Override 31 | public Address determineMyLocalAddress(DiscoveryNode localDiscoveryNode, Map registratorConfig) { 32 | 33 | Address myLocalAddress = localDiscoveryNode.getPrivateAddress(); 34 | 35 | Object usePublicAddress = (Object)registratorConfig.get(CONFIG_PROP_PREFER_PUBLIC_ADDRESS); 36 | if (usePublicAddress != null && usePublicAddress instanceof Boolean && (Boolean)usePublicAddress) { 37 | logger.info("Registrator config property: " + CONFIG_PROP_PREFER_PUBLIC_ADDRESS +":"+usePublicAddress + " attempting to use it..."); 38 | Address publicAddress = localDiscoveryNode.getPublicAddress(); 39 | if (publicAddress != null) { 40 | myLocalAddress = publicAddress; 41 | } 42 | } 43 | 44 | return myLocalAddress; 45 | } 46 | 47 | 48 | } 49 | -------------------------------------------------------------------------------- /src/main/resources/META-INF/services/com.hazelcast.spi.discovery.DiscoveryStrategyFactory: -------------------------------------------------------------------------------- 1 | org.bitsofinfo.hazelcast.discovery.etcd.EtcdDiscoveryStrategyFactory -------------------------------------------------------------------------------- /src/main/resources/doNothingRegistrator-example.xml: -------------------------------------------------------------------------------- 1 | 2 | 6 | 7 | hazelcast-etcd-discovery-spi 8 | haz3lcast1 9 | 10 | 11 | 12 | true 13 | false 14 | 15 | 16 | 17 | 5701 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 28 | 29 | 30 | http://localhost:4001 31 | hz-discovery-test-cluster 32 | 0 33 | org.bitsofinfo.hazelcast.discovery.etcd.DoNothingRegistrator 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | -------------------------------------------------------------------------------- /src/main/resources/explicitIpPortRegistrator-example.xml: -------------------------------------------------------------------------------- 1 | 2 | 6 | 7 | 9 | 10 | hazelcast-etcd-discovery-spi 11 | haz3lcast1 12 | 13 | 14 | 15 | true 16 | false 17 | 18 | 19 | 20 | 5701 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 31 | 32 | 33 | http://localhost:4001 34 | hz-discovery-test-cluster 35 | 10000 36 | org.bitsofinfo.hazelcast.discovery.etcd.ExplicitIpPortRegistrator 37 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | -------------------------------------------------------------------------------- /src/main/resources/hazelcast-etcd-discovery-spi-example.xml: -------------------------------------------------------------------------------- 1 | 2 | 6 | 7 | hazelcast-etcd-discovery-spi 8 | haz3lcast1 9 | 10 | 11 | 12 | true 13 | false 14 | 15 | 16 | 17 | 5701 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 29 | 30 | 31 | 36 | http://localhost:4001 37 | 38 | 43 | hz-discovery-test-cluster 44 | 45 | 46 | 51 | 52 | 57 | 58 | 65 | 10000 66 | 67 | 85 | 86 | 110 | org.bitsofinfo.hazelcast.discovery.etcd.LocalDiscoveryNodeRegistrator 111 | 112 | 120 | 125 | 126 | 127 | 128 | 141 | 142 | 143 | 144 | 145 | 146 | 147 | 148 | 149 | 150 | -------------------------------------------------------------------------------- /src/main/resources/localDiscoveryNodeRegistrator-example.xml: -------------------------------------------------------------------------------- 1 | 2 | 6 | 7 | hazelcast-etcd-discovery-spi 8 | haz3lcast1 9 | 10 | 11 | 12 | true 13 | false 14 | 15 | 16 | 17 | 5701 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 28 | 29 | 30 | http://localhost:4001 31 | hz-discovery-test-cluster 32 | 10000 33 | org.bitsofinfo.hazelcast.discovery.etcd.LocalDiscoveryNodeRegistrator 34 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | -------------------------------------------------------------------------------- /src/test/java/org/bitsofinfo/hazelcast/discovery/etcd/ManualRunner.java: -------------------------------------------------------------------------------- 1 | package org.bitsofinfo.hazelcast.discovery.etcd; 2 | 3 | import com.hazelcast.config.ClasspathXmlConfig; 4 | import com.hazelcast.config.Config; 5 | import com.hazelcast.core.Hazelcast; 6 | import com.hazelcast.core.HazelcastInstance; 7 | 8 | /** 9 | * Simple class for manually spawning hz instances and watching what happens 10 | * as they discover one another 11 | * 12 | * @author bitsofinfo 13 | * 14 | */ 15 | public class ManualRunner { 16 | 17 | public static void main(String[] args) throws Exception { 18 | 19 | Config conf =new ClasspathXmlConfig("hazelcast-etcd-discovery-spi-example.xml"); 20 | 21 | HazelcastInstance hazelcastInstance = Hazelcast.newHazelcastInstance(conf); 22 | 23 | Thread.currentThread().sleep(30000); 24 | 25 | System.exit(0); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/test/java/org/bitsofinfo/hazelcast/discovery/etcd/RegistratorTestBase.java: -------------------------------------------------------------------------------- 1 | package org.bitsofinfo.hazelcast.discovery.etcd; 2 | 3 | import java.net.InetAddress; 4 | import java.net.URI; 5 | import java.net.UnknownHostException; 6 | import java.util.ArrayList; 7 | import java.util.List; 8 | import java.util.Random; 9 | import java.util.concurrent.TimeUnit; 10 | 11 | import org.junit.Assert; 12 | 13 | import com.hazelcast.config.ClasspathXmlConfig; 14 | import com.hazelcast.config.Config; 15 | import com.hazelcast.core.Hazelcast; 16 | import com.hazelcast.core.HazelcastInstance; 17 | import com.hazelcast.core.IMap; 18 | import com.hazelcast.nio.Address; 19 | 20 | import mousio.etcd4j.EtcdClient; 21 | import mousio.etcd4j.responses.EtcdKeysResponse; 22 | 23 | /** 24 | * Base test class for the Hazelcast Etcd Discovery SPI strategies 25 | * writing registrators 26 | * 27 | * @author bitsofinfo 28 | * 29 | */ 30 | public abstract class RegistratorTestBase { 31 | 32 | public static final String ETCD_HOST = "localhost"; 33 | public static final int ETCD_PORT = 4001; 34 | 35 | protected abstract void preConstructHazelcast(int instanceNumber) throws Exception; 36 | 37 | protected void testRegistrator(String hazelcastConfigXmlFilename, String serviceName) { 38 | testRegistrator(hazelcastConfigXmlFilename, serviceName, null, null); 39 | } 40 | 41 | protected void testRegistrator(String hazelcastConfigXmlFilename, String serviceName, String username, String password) { 42 | EtcdClient etcdClient = null; 43 | 44 | try { 45 | 46 | IMap testMap1 = null; 47 | IMap testMap2 = null; 48 | 49 | int totalInstancesToTest = 5; 50 | List instances = new ArrayList(); 51 | 52 | System.out.println("#################### IS ETCD RUNNING @ " + 53 | ETCD_HOST+":"+ETCD_PORT+"? IF NOT THIS TEST WILL FAIL! ####################"); 54 | 55 | etcdClient = new EtcdClient(username, password, new URI("http://"+ETCD_HOST+":"+ETCD_PORT)); 56 | 57 | for (int i=0; i testMap1 = null; 63 | 64 | int totalInstancesToTest = 5; 65 | List instances = new ArrayList(); 66 | 67 | System.out.println("#################### IS ETCD RUNNING @ " + 68 | ETCD_HOST+":"+ETCD_PORT+"? IF NOT THIS TEST WILL FAIL! ####################"); 69 | 70 | 71 | etcdClient = new EtcdClient(new URI("http://"+ETCD_HOST+":"+ETCD_PORT)); 72 | 73 | 74 | for (int i=0; i 2 | 6 | 7 | 13 | 14 | test-DoNothingRegistrator 15 | haz3lcast1 16 | 17 | 18 | 19 | true 20 | false 21 | 22 | 23 | 24 | 5701 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 35 | 36 | 37 | http://localhost:4001 38 | test-DoNothingRegistrator 39 | 0 40 | 41 | org.bitsofinfo.hazelcast.discovery.etcd.DoNothingRegistrator 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 127.0.0.1 50 | 51 | 52 | 53 | -------------------------------------------------------------------------------- /src/test/resources/test-ExplicitIpPortRegistrator.xml: -------------------------------------------------------------------------------- 1 | 2 | 6 | 7 | 13 | 14 | test-ExplicitIpPortRegistrator 15 | haz3lcast1 16 | 17 | 18 | 19 | true 20 | false 21 | 22 | 23 | 24 | 5801 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 35 | 36 | 37 | http://localhost:4001 38 | test-ExplicitIpPortRegistrator 39 | 10000 40 | 41 | org.bitsofinfo.hazelcast.discovery.etcd.ExplicitIpPortRegistrator 42 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | -------------------------------------------------------------------------------- /src/test/resources/test-LocalDiscoveryNodeRegistrator.xml: -------------------------------------------------------------------------------- 1 | 2 | 6 | 7 | 13 | 14 | test-LocalDiscoveryNodeRegistrator 15 | haz3lcast1 16 | 17 | 18 | 19 | true 20 | false 21 | 22 | 23 | 24 | 5701 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 35 | 36 | 37 | http://localhost:4001 38 | test-LocalDiscoveryNodeRegistrator 39 | 10000 40 | 41 | org.bitsofinfo.hazelcast.discovery.etcd.LocalDiscoveryNodeRegistrator 42 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | -------------------------------------------------------------------------------- /src/test/resources/test-LocalDiscoveryNodeRegistratorWithUsernameAndPassword.xml: -------------------------------------------------------------------------------- 1 | 2 | 6 | 7 | 13 | 14 | test-LocalDiscoveryNodeRegistratorWithUsernameAndPassword 15 | haz3lcast1 16 | 17 | 18 | 19 | true 20 | false 21 | 22 | 23 | 24 | 5701 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 35 | 36 | 37 | http://localhost:4001 38 | root 39 | password 40 | test-LocalDiscoveryNodeRegistratorWithUsernameAndPassword 41 | 10000 42 | 43 | org.bitsofinfo.hazelcast.discovery.etcd.LocalDiscoveryNodeRegistrator 44 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | --------------------------------------------------------------------------------