From 5b5d5522eb45a8c334f273ce72bfd8bbfa94944c Mon Sep 17 00:00:00 2001 From: antelder Date: Sun, 25 Apr 2010 21:40:53 +0000 Subject: Update hazelcast registry to use runtime properties git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@937890 13f79535-47bb-0310-9956-ffa450edef68 --- .../sca/endpoint/hazelcast/RegistryConfig.java | 176 +++++++++++++++++++++ 1 file changed, 176 insertions(+) create mode 100644 sca-java-2.x/trunk/modules/endpoint-hazelcast/src/main/java/org/apache/tuscany/sca/endpoint/hazelcast/RegistryConfig.java (limited to 'sca-java-2.x/trunk/modules/endpoint-hazelcast/src/main/java/org/apache/tuscany/sca/endpoint/hazelcast/RegistryConfig.java') diff --git a/sca-java-2.x/trunk/modules/endpoint-hazelcast/src/main/java/org/apache/tuscany/sca/endpoint/hazelcast/RegistryConfig.java b/sca-java-2.x/trunk/modules/endpoint-hazelcast/src/main/java/org/apache/tuscany/sca/endpoint/hazelcast/RegistryConfig.java new file mode 100644 index 0000000000..da604d717b --- /dev/null +++ b/sca-java-2.x/trunk/modules/endpoint-hazelcast/src/main/java/org/apache/tuscany/sca/endpoint/hazelcast/RegistryConfig.java @@ -0,0 +1,176 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.tuscany.sca.endpoint.hazelcast; + +import java.net.InetAddress; +import java.net.NetworkInterface; +import java.util.ArrayList; +import java.util.Enumeration; +import java.util.List; +import java.util.Properties; + + +/** + * Utility to parse the config properties. + * + * bind - ip[:port] - defines the local bind address and port, it defaults to the network interface with the widest + * class (ie class A is wider than class B) on port 14820 and if that port in use it will try + * incrementing by one till a free port is found. + * + * multicast - groupip:port | off - defines if multicast discovery is used and if so what multicast ip group and port is used + * defaults to 224.5.12.10:51482. A value of off means multicast is disabled. + * + * wka - ip[:port] - a comma separated list of ip address and port for remote nodes in the domain group. The port defaults to 14820. + * + * userid - is the userid other nodes must use to connect to this domain group. The default is the default domain name. + * + * password - is the password other nodes must use to connect to this domain group. The default is 'tuscany'. + * + * client - true means this is an SCAClient call + * + */ +public class RegistryConfig { + + private String bindAddress; + private int bindPort = 14820; + private boolean multicastDisabled = false; + private String multicastAddress = "224.5.12.10"; + private int multicastPort = 51482; + private List wkas = new ArrayList(); + private String userid; + private String password; + boolean client; + + public RegistryConfig(Properties properties) { + init(properties); + } + + private void init(Properties properties) { + + String bindValue = properties.getProperty("bind"); + if (bindValue == null) { + this.bindAddress = chooseLocalAddress().getHostAddress(); + } else { + if (bindValue.indexOf(":") == -1) { + this.bindAddress = bindValue; + } else { + String[] addr = bindValue.split(":"); + this.bindAddress = addr[0]; + this.bindPort = Integer.parseInt(addr[1]); + } + } + + String multicastValue = properties.getProperty("multicast"); + if (multicastValue != null) { + if ("off".equalsIgnoreCase(multicastValue)) { + this.multicastDisabled = true; + } else { + if (multicastValue.indexOf(":") == -1) { + this.multicastAddress = multicastValue; + } else { + String[] addr = multicastValue.split(":"); + this.multicastAddress = addr[0]; + this.multicastPort = Integer.parseInt(addr[1]); + } + } + } + + String wkaValue = properties.getProperty("wka"); + if (wkaValue != null) { + String[] ips = wkaValue.split(","); + for (String ip : ips) { + if (ip.indexOf(":") == -1) { + wkas.add(ip + ":14820"); + } else { + wkas.add(ip); + } + } + } + + this.client = Boolean.parseBoolean(properties.getProperty("client", "false")); + this.password = properties.getProperty("password", "tuscany"); + this.userid = properties.getProperty("userid", properties.getProperty("defaultDomainName", "default")); + + } + + public String getBindAddress() { + return bindAddress; + } + + public int getBindPort() { + return bindPort; + } + + public boolean isMulticastDisabled() { + return multicastDisabled; + } + + public String getMulticastAddress() { + return multicastAddress; + } + + public int getMulticastPort() { + return multicastPort; + } + + public List getWKAs() { + return wkas; + } + + public String getUserid() { + return userid; + } + public String getPassword() { + return password; + } + + /** + * Use the NIC address with the widest class, ie class A instead of class B or C. + * Bit crude but in a lot of environments a class A address (eg 10.x.x.x) is likely + * a better choice than a class C address (eg 192.x.x.x). And the alternative to + * this is to just choose the first address of the first network interface which + * likely isn't a better choice than this approach. + */ + protected InetAddress chooseLocalAddress() { + InetAddress chosen = null; + try { + Enumeration nis = NetworkInterface.getNetworkInterfaces(); + while (nis.hasMoreElements()) { + NetworkInterface ni = nis.nextElement(); + Enumeration ips = ni.getInetAddresses(); + while (ips.hasMoreElements()) { + InetAddress addr = ips.nextElement(); + if (!addr.isLoopbackAddress()) { + if (chosen == null) { + chosen = addr; + } else { + if (((int) addr.getAddress()[0] & 0xFF) < ((int) chosen.getAddress()[0] & 0xFF)) { + chosen = addr; + } + } + } + } + } + } catch (Exception e) { + // ignore + } + return chosen; + } +} -- cgit v1.2.3