org.cristalise.kernel.entity.proxy.ProxyManager Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of cristalise-kernel Show documentation
Show all versions of cristalise-kernel Show documentation
Cristal-ise is a description-driven software platform originally developed to track the construction of
the CMS ECAL detector of the LHC at CERN. This is its core library, known as the kernel, which manages
business objects called Items. Items are entirely configured from data, called descriptions, held in other Items.
Every change of a state in an Item is a consequence of an execution of an activity in that Item's lifecycle,
meaning that Cristal-ise applications are completely traceable, even in their design. It also supports extensive
versioning of Item description data, giving the system a high level of flexibility.
/**
* This file is part of the CRISTAL-iSE kernel.
* Copyright (c) 2001-2015 The CRISTAL Consortium. All rights reserved.
*
* This library is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as published
* by the Free Software Foundation; either version 3 of the License, or (at
* your option) any later version.
*
* This library is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; with out even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
* License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this library; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
*
* http://www.fsf.org/licensing/licenses/lgpl.html
*/
package org.cristalise.kernel.entity.proxy;
import static org.cristalise.kernel.property.BuiltInItemProperties.NAME;
import static org.cristalise.kernel.property.BuiltInItemProperties.TYPE;
import java.util.ArrayList;
import java.util.ConcurrentModificationException;
import java.util.HashMap;
import java.util.Iterator;
import org.cristalise.kernel.common.InvalidDataException;
import org.cristalise.kernel.common.ObjectNotFoundException;
import org.cristalise.kernel.lookup.AgentPath;
import org.cristalise.kernel.lookup.DomainPath;
import org.cristalise.kernel.lookup.InvalidItemPathException;
import org.cristalise.kernel.lookup.ItemPath;
import org.cristalise.kernel.lookup.Path;
import org.cristalise.kernel.persistency.ClusterType;
import org.cristalise.kernel.process.Gateway;
import org.cristalise.kernel.property.Property;
import org.cristalise.kernel.utils.Logger;
import org.cristalise.kernel.utils.SoftCache;
/**
* Manager of pool of Proxies and their subscribers
*/
public class ProxyManager {
public static final String CONFIG_STRICT_POLICY = "ProxyManager.strictPolicy";
SoftCache proxyPool = new SoftCache(50);
HashMap treeSubscribers = new HashMap();
HashMap connections = new HashMap();
ProxyMessageListener messageListener = null;
/**
* Create a proxy manager to listen for proxy events and reap unused proxies
*/
public ProxyManager() throws InvalidDataException {
Logger.msg(5, "ProxyManager() - Starting.....");
Iterator servers = Gateway.getLookup().search(new DomainPath("/servers"), new Property(TYPE, "Server", false));
while(servers.hasNext()) {
Path thisServerResult = servers.next();
try {
ItemPath thisServerPath = thisServerResult.getItemPath();
String remoteServer = ((Property)Gateway.getStorage().get(thisServerPath, ClusterType.PROPERTY+"/"+NAME, null)).getValue();
String portStr = ((Property)Gateway.getStorage().get(thisServerPath, ClusterType.PROPERTY+"/ProxyPort", null)).getValue();
connectToProxyServer(remoteServer, Integer.parseInt(portStr));
}
catch (Exception ex) {
Logger.error("Exception retrieving proxy server connection data for "+thisServerResult);
Logger.error(ex);
}
}
try {
if (Gateway.getProperties().containsKey("ProxyMessageListener")) {
messageListener = (ProxyMessageListener) Gateway.getProperties().getInstance("ProxyMessageListener");
}
}
catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
Logger.error(e);
throw new InvalidDataException(e.getMessage());
}
}
public void connectToProxyServer(String name, int port) {
ProxyServerConnection oldConn = connections.get(name);
if (oldConn != null) oldConn.shutdown();
connections.put(name, new ProxyServerConnection(name, port, this));
}
protected void resubscribe(ProxyServerConnection conn) {
synchronized (proxyPool) {
for (ItemPath key : proxyPool.keySet()) {
ProxyMessage sub = new ProxyMessage(key, ProxyMessage.ADDPATH, false);
Logger.msg(5, "ProxyManager.resubscribe() - item:"+key);
conn.sendMessage(sub);
}
}
}
/**
* @param sub
*/
private void sendMessage(ProxyMessage sub) {
for (ProxyServerConnection element : connections.values()) {
element.sendMessage(sub);
}
}
public void shutdown() {
Logger.msg("ProxyManager.shutdown() - flagging shutdown of server connections");
for (ProxyServerConnection element : connections.values()) {
element.shutdown();
}
}
protected void processMessage(ProxyMessage thisMessage) throws InvalidDataException {
if (Logger.doLog(9)) Logger.msg(9, thisMessage.toString());
if (thisMessage.getPath().equals(ProxyMessage.PINGPATH)) // ping response
return;
if (thisMessage.getItemPath() == null) {
// must be domain path info
informTreeSubscribers(thisMessage.isState(), thisMessage.getPath());
}
else {
// proper proxy message
Logger.msg(5, "ProxyManager.processMessage() - Received proxy message: "+thisMessage.toString());
ItemProxy relevant = proxyPool.get(thisMessage.getItemPath());
if (relevant == null) {
Logger.warning("Received proxy message for sysKey "+thisMessage.getItemPath()+" which we don't have a proxy for.");
}
else {
try {
relevant.notify(thisMessage);
}
catch (Throwable ex) {
Logger.error("Error caught notifying proxy listener "+relevant.toString()+" of "+thisMessage.toString());
Logger.error(ex);
}
}
}
if (messageListener != null) messageListener.notifyMessage(thisMessage);
}
private void informTreeSubscribers(boolean state, String path) {
DomainPath last = new DomainPath(path);
DomainPath parent;
boolean first = true;
synchronized (treeSubscribers) {
while ((parent = last.getParent()) != null) {
ArrayList currentKeys = new ArrayList();
currentKeys.addAll(treeSubscribers.keySet());
for (DomainPathSubscriber sub : currentKeys) {
DomainPath interest = treeSubscribers.get(sub);
if (interest != null && interest.equals(parent)) {
if (state == ProxyMessage.ADDED) sub.pathAdded(last);
else if (first) sub.pathRemoved(last);
}
}
last = parent;
first = false;
}
}
}
public void subscribeTree(DomainPathSubscriber sub, DomainPath interest) {
synchronized(treeSubscribers) {
treeSubscribers.put(sub, interest);
}
}
public void unsubscribeTree(DomainPathSubscriber sub) {
synchronized(treeSubscribers) {
treeSubscribers.remove(sub);
}
}
private ItemProxy createProxy( org.omg.CORBA.Object ior, ItemPath itemPath) throws ObjectNotFoundException {
ItemProxy newProxy = null;
Logger.msg(5, "ProxyManager.createProxy() - Item:" + itemPath);
if( itemPath instanceof AgentPath ) {
newProxy = new AgentProxy(ior, (AgentPath)itemPath);
}
else {
newProxy = new ItemProxy(ior, itemPath);
}
// subscribe to changes from server
ProxyMessage sub = new ProxyMessage(itemPath, ProxyMessage.ADDPATH, false);
sendMessage(sub);
reportCurrentProxies(9);
return ( newProxy );
}
protected void removeProxy( ItemPath itemPath ) {
ProxyMessage sub = new ProxyMessage(itemPath, ProxyMessage.DELPATH, true);
Logger.msg(5,"ProxyManager.removeProxy() - Unsubscribing to proxy informer for "+itemPath);
sendMessage(sub);
}
/**
* Called by the other GetProxy methods to either load the find the proxy in the cache
* or create it from the ItemPath.
*
* @param ior
* @param itemPath
* @return the ItemProx
* @throws ObjectNotFoundException
*/
private ItemProxy getProxy( org.omg.CORBA.Object ior, ItemPath itemPath) throws ObjectNotFoundException {
synchronized(proxyPool) {
ItemProxy newProxy;
// return it if it exists
newProxy = proxyPool.get(itemPath);
// create a new one
if (newProxy == null) {
newProxy = createProxy(ior, itemPath);
proxyPool.put(itemPath, newProxy);
}
return newProxy;
}
}
public ItemProxy getProxy( Path path ) throws ObjectNotFoundException {
ItemPath itemPath = null;
Logger.msg(8,"ProxyManager.getProxy(" + path.toString() + ")");
if (path instanceof ItemPath) {
try {
//issue #165: get ItemPath from Lookup to ensure it is a correct class
itemPath = Gateway.getLookup().getItemPath(((ItemPath)path).getUUID().toString());
}
catch (InvalidItemPathException e) {
throw new ObjectNotFoundException(e.getMessage());
}
}
else if (path instanceof DomainPath) {
//issue #165: reset target to enforce to read target from Lookup
((DomainPath) path).setTargetUUID(null);
itemPath = path.getItemPath();
}
if (itemPath == null) throw new ObjectNotFoundException("Cannot use RolePath");
return getProxy( itemPath.getIOR(), itemPath );
}
public AgentProxy getAgentProxy( String agentName ) throws ObjectNotFoundException {
AgentPath path = Gateway.getLookup().getAgentPath(agentName);
return (AgentProxy) getProxy(path);
}
public AgentProxy getAgentProxy( AgentPath path ) throws ObjectNotFoundException {
return (AgentProxy) getProxy(path);
}
/**
* A utility to Dump the current proxies loaded
*
* @param logLevel the selectd log level
*/
public void reportCurrentProxies(int logLevel) {
if (!Logger.doLog(logLevel)) return;
Logger.msg(logLevel, "Current proxies: ");
try {
synchronized(proxyPool) {
Iterator i = proxyPool.keySet().iterator();
for( int count=0; i.hasNext(); count++ ) {
ItemPath nextProxy = i.next();
ItemProxy thisProxy = proxyPool.get(nextProxy);
if (thisProxy != null) {
Logger.msg(logLevel, ""+count + ": "+proxyPool.get(nextProxy).getClass().getName()+": "+nextProxy);
}
}
}
}
catch (ConcurrentModificationException ex) {
Logger.msg(logLevel, "Proxy cache modified. Aborting.");
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy