@Override public int compareTo(Object o) { ServerLocation other = (ServerLocation) o; int difference = hostName.compareTo(other.hostName); if (difference != 0) { return difference; } return port - other.getPort(); }
/** * Test hook that returns an int which the port of the primary server. -1 is returned if we have * no primary. */ public int getPrimaryPort() { int result = -1; ServerLocation sl = getPrimary(); if (sl != null) { result = sl.getPort(); } return result; }
@Override public String toString() { StringBuffer sb = new StringBuffer(); sb.append("EndPoints["); synchronized (this) { Iterator it = serverList.iterator(); while (it.hasNext()) { ServerLocation loc = (ServerLocation) it.next(); sb.append(loc.getHostName() + ":" + loc.getPort()); if (it.hasNext()) { sb.append(","); } } } sb.append("]"); return sb.toString(); }
/** * Test hook that returns a list of server names (host+port); one for each server we are currently * connected to. */ public List<String> getCurrentServerNames() { List<ServerLocation> servers = getCurrentServers(); ArrayList<String> result = new ArrayList(servers.size()); Iterator it = servers.iterator(); while (it.hasNext()) { ServerLocation sl = (ServerLocation) it.next(); String name = sl.getHostName() + sl.getPort(); result.add(name); } return result; }
/** * Test hook that returns a string consisting of the host name and port of the primary server. * Null is returned if we have no primary. */ public String getPrimaryName() { String result = null; ServerLocation sl = getPrimary(); if (sl != null) { result = sl.getHostName() + sl.getPort(); } return result; }
static List constructGetAllTasks(String region, final Map<ServerLocation, HashSet> serverToFilterMap, final PoolImpl pool, final Object callback) { final List<SingleHopOperationCallable> tasks = new ArrayList<SingleHopOperationCallable>(); ArrayList<ServerLocation> servers = new ArrayList<ServerLocation>(serverToFilterMap.keySet()); if (logger.isDebugEnabled()) { logger.debug("Constructing tasks for the servers {}", servers); } for (ServerLocation server : servers) { Set filterSet = serverToFilterMap.get(server); AbstractOp getAllOp = new GetAllOpImpl(region, new ArrayList(filterSet), callback); SingleHopOperationCallable task = new SingleHopOperationCallable(new ServerLocation(server.getHostName(), server.getPort()), pool, getAllOp, UserAttributes.userAttributes.get()); tasks.add(task); } return tasks; }
@Override public String toString() { return getName() + " (" + this.location.getHostName() + ':' + this.location.getPort() + ')'; }
@Override public Set<InetSocketAddress> getCurrentServers() { Map<String, Pool> pools = PoolManager.getAll(); Set<InetSocketAddress> result = null; for (Pool pool : pools.values()) { PoolImpl poolImpl = (PoolImpl) pool; for (ServerLocation serverLocation : poolImpl.getCurrentServers()) { if (result == null) { result = new HashSet<>(); } result.add(new InetSocketAddress(serverLocation.getHostName(), serverLocation.getPort())); } } if (result == null) { return Collections.emptySet(); } else { return result; } }
org.apache.geode.cache.client.internal.Endpoint ep = (org.apache.geode.cache.client.internal.Endpoint) entry.getValue(); String server = loc.getHostName() + "[" + loc.getPort() + "]"; Integer count = (Integer) map.get(server); if (count == null) {
@Override public ClientUpdater createServerToClientConnection(Endpoint endpoint, QueueManager qManager, boolean isPrimary, ClientUpdater failedUpdater) { String clientUpdateName = CacheClientUpdater.CLIENT_UPDATER_THREAD_NAME + " on " + endpoint.getMemberId() + " port " + endpoint.getLocation().getPort(); if (logger.isDebugEnabled()) { logger.debug("Establishing: {}", clientUpdateName); } // Launch the thread CacheClientUpdater updater = connectionConnector.connectServerToClient(endpoint, qManager, isPrimary, failedUpdater, clientUpdateName); return updater; } }
static List constructAndGetPutAllTasks(Region region, final Map map, final EventID eventId, boolean skipCallbacks, final Map<ServerLocation, HashSet> serverToFilterMap, final PoolImpl pool, Object callbackArg) { final List<SingleHopOperationCallable> tasks = new ArrayList<SingleHopOperationCallable>(); ArrayList<ServerLocation> servers = new ArrayList<ServerLocation>(serverToFilterMap.keySet()); if (logger.isDebugEnabled()) { logger.debug("Constructing tasks for the servers {}", servers); } for (ServerLocation server : servers) { Set filterSet = serverToFilterMap.get(server); Map newKeysValuesMap = new LinkedHashMap(); // iterator 1: for single hop, both iterator filterSet and newKeysValuesMap for (Object key : filterSet) { newKeysValuesMap.put(key, map.get(key)); } AbstractOp putAllOp = new PutAllOpImpl(region, newKeysValuesMap, eventId, true, skipCallbacks, callbackArg); SingleHopOperationCallable task = new SingleHopOperationCallable(new ServerLocation(server.getHostName(), server.getPort()), pool, putAllOp, UserAttributes.userAttributes.get()); tasks.add(task); } return tasks; }
/** * Test hook that returns a list of strings. Each string consists of the host name and port of a * redundant server. An empty list is returned if we have no redundant servers. */ public List<String> getRedundantNames() { List result = Collections.emptyList(); if (this.queueManager != null) { QueueManager.QueueConnections cons = this.queueManager.getAllConnections(); List<Connection> backupCons = cons.getBackups(); if (backupCons.size() > 0) { result = new ArrayList(backupCons.size()); Iterator<Connection> it = backupCons.iterator(); while (it.hasNext()) { Connection con = it.next(); ServerLocation sl = con.getServer(); result.add(sl.getHostName() + sl.getPort()); } } } return result; }
static List constructAndGetRemoveAllTasks(Region region, final EventID eventId, final Map<ServerLocation, HashSet> serverToFilterMap, final PoolImpl pool, Object callbackArg) { final List<SingleHopOperationCallable> tasks = new ArrayList<SingleHopOperationCallable>(); ArrayList<ServerLocation> servers = new ArrayList<ServerLocation>(serverToFilterMap.keySet()); if (logger.isDebugEnabled()) { logger.debug("Constructing tasks for the servers{}", servers); } for (ServerLocation server : servers) { AbstractOp RemoveAllOp = new RemoveAllOpImpl(region, serverToFilterMap.get(server), eventId, true, callbackArg); SingleHopOperationCallable task = new SingleHopOperationCallable(new ServerLocation(server.getHostName(), server.getPort()), pool, RemoveAllOp, UserAttributes.userAttributes.get()); tasks.add(task); } return tasks; }
static List<SingleHopOperationCallable> constructAndGetExecuteFunctionTasks(String region, ServerRegionFunctionExecutor serverRegionExecutor, final Map<ServerLocation, ? extends HashSet> serverToFilterMap, final PoolImpl pool, final Function function, byte hasResult, ResultCollector rc, ClientMetadataService cms, boolean allBucket) { final List<SingleHopOperationCallable> tasks = new ArrayList<SingleHopOperationCallable>(); ArrayList<ServerLocation> servers = new ArrayList<ServerLocation>(serverToFilterMap.keySet()); if (logger.isDebugEnabled()) { logger.debug("Constructing tasks for the servers {}", servers); } for (ServerLocation server : servers) { ServerRegionFunctionExecutor executor = (ServerRegionFunctionExecutor) serverRegionExecutor .withFilter(serverToFilterMap.get(server)); AbstractOp op = new ExecuteRegionFunctionSingleHopOpImpl(region, function, executor, rc, hasResult, new HashSet<String>(), allBucket); SingleHopOperationCallable task = new SingleHopOperationCallable(new ServerLocation(server.getHostName(), server.getPort()), pool, op, UserAttributes.userAttributes.get()); tasks.add(task); } return tasks; }
static List<SingleHopOperationCallable> constructAndGetExecuteFunctionTasks(String region, ServerRegionFunctionExecutor serverRegionExecutor, final Map<ServerLocation, ? extends HashSet> serverToFilterMap, final PoolImpl pool, final String functionId, byte hasResult, ResultCollector rc, ClientMetadataService cms, boolean allBucket, boolean isHA, boolean optimizeForWrite) { final List<SingleHopOperationCallable> tasks = new ArrayList<SingleHopOperationCallable>(); ArrayList<ServerLocation> servers = new ArrayList<ServerLocation>(serverToFilterMap.keySet()); if (logger.isDebugEnabled()) { logger.debug("Constructing tasks for the servers {}", servers); } for (ServerLocation server : servers) { ServerRegionFunctionExecutor executor = (ServerRegionFunctionExecutor) serverRegionExecutor .withFilter(serverToFilterMap.get(server)); AbstractOp op = new ExecuteRegionFunctionSingleHopOpImpl(region, functionId, executor, rc, hasResult, new HashSet<String>(), allBucket, isHA, optimizeForWrite); SingleHopOperationCallable task = new SingleHopOperationCallable(new ServerLocation(server.getHostName(), server.getPort()), pool, op, UserAttributes.userAttributes.get()); tasks.add(task); } return tasks; }
for (Iterator<ServerLocation> itr = locatorResponse.iterator(); itr.hasNext();) { ServerLocation locator = itr.next(); InetSocketAddress address = new InetSocketAddress(locator.getHostName(), locator.getPort()); HostAddress hostAddress = new HostAddress(address, locator.getHostName()); newLocatorAddresses.add(hostAddress);
public ServerQueueStatus connect(EndpointManager endpointManager, ServerLocation location, ClientSideHandshake handshake, int socketBufferSize, int handshakeTimeout, int readTimeout, CommunicationMode communicationMode, GatewaySender sender, SocketCreator sc) throws IOException { theSocket = sc.connectForClient(location.getHostName(), location.getPort(), handshakeTimeout, socketBufferSize); theSocket.setTcpNoDelay(true); theSocket.setSendBufferSize(socketBufferSize); // Verify buffer sizes verifySocketBufferSize(socketBufferSize, theSocket.getReceiveBufferSize(), "receive"); verifySocketBufferSize(socketBufferSize, theSocket.getSendBufferSize(), "send"); theSocket.setSoTimeout(handshakeTimeout); out = theSocket.getOutputStream(); in = theSocket.getInputStream(); this.status = handshake.handshakeWithServer(this, location, communicationMode); commBuffer = ServerConnection.allocateCommBuffer(socketBufferSize, theSocket); if (sender != null) { commBufferForAsyncRead = ServerConnection.allocateCommBuffer(socketBufferSize, theSocket); } theSocket.setSoTimeout(readTimeout); endpoint = endpointManager.referenceEndpoint(location, this.status.getMemberId()); this.connectFinished = true; this.endpoint.getStats().incConnections(1); return status; }
LocatorAPI.GetServerResponse.Builder builder = LocatorAPI.GetServerResponse.newBuilder(); BasicTypes.Server.Builder serverBuilder = BasicTypes.Server.newBuilder(); serverBuilder.setHostname(serverLocation.getHostName()).setPort(serverLocation.getPort()); BasicTypes.Server server = serverBuilder.build(); builder.setServer(server);
/** * Creates a new InternalDistributedMember for use in notifying membership listeners. The version * information in the ID is set to Version.CURRENT. * * @param location the coordinates of the server */ public InternalDistributedMember(ServerLocation location) { this.hostName = location.getHostName(); final InetAddress addr; try { addr = hostnameResolver.getInetAddress(location); } catch (UnknownHostException e) { throw new ServerConnectivityException("Unable to resolve server location " + location, e); } netMbr = MemberFactory.newNetMember(addr, location.getPort()); netMbr.setVmKind(ClusterDistributionManager.NORMAL_DM_TYPE); versionObj = Version.CURRENT; netMbr.setVersion(versionObj); }
if (bucketServerLocation != null) { location = new ServerLocation(bucketServerLocation.getHostName(), bucketServerLocation.getPort());