jive3.TreePanelHostCollection Maven / Gradle / Ivy
The newest version!
package jive3;
import fr.esrf.Tango.DevFailed;
import fr.esrf.Tango.DevState;
import fr.esrf.Tango.DevVarLongStringArray;
import fr.esrf.TangoApi.*;
import fr.esrf.tangoatk.widget.util.ATKGraphicsUtils;
import jive.DevWizard;
import jive.JiveUtils;
import jive.ServerDlg;
import jive.ThreadDlg;
import javax.swing.*;
import javax.swing.event.TreeExpansionEvent;
import javax.swing.tree.TreePath;
import java.awt.*;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.StringTokenizer;
/**
* A panel for selecting host collection (Astor display)
*/
public class TreePanelHostCollection extends TreePanel {
public static int NB_LEVELS = 5;
public TreePanelHostCollection() {
this.self = this;
setLayout(new BorderLayout());
}
public TangoNode createRoot() {
return new RootNode();
}
String getLevelStr(int level) {
if(level==0)
return "Not Controlled";
else
return "Level " + Integer.toString(level);
}
DevState[] getServerState(DeviceProxy starter,String[] serverNames) throws DevFailed {
DevState[] retStates = new DevState[serverNames.length];
for(int i=0;i=0) {
if(st.equalsIgnoreCase("FAULT")) {
retStates[idx] = DevState.OFF;
} else {
retStates[idx] = DevState.ON;
}
}
}
return retStates;
}
String getHostStateString(DevState state) {
switch(state.value()) {
case DevState._ON:
return "All servers are running";
case DevState._OFF:
return "All servers are stopped";
case DevState._ALARM:
return "At least one of the servers is stopped";
case DevState._MOVING:
return "At least one of the servers is not responding";
case DevState._FAULT:
return "FAULT";
default:
return "Not responding";
}
}
String getServerStateString(DevState state) {
if(state==DevState.OFF)
return "Stopped";
else if(state==DevState.ON)
return "Running";
else
return "Unknown";
}
boolean allServersOff(DevState[] allStates) {
boolean off = true;
int i=0;
while(off && i0 ) {
JiveUtils.sleep(1000);
srvState = getServerState(starter,serverNames);
nbTry--;
if( !allServersOff(srvState) && nbTry==0 ) {
int ok = JOptionPane.showConfirmDialog(null,"Some servers are still running.\nSend Hard kill ?","Question",JOptionPane.YES_NO_OPTION);
if( ok==JOptionPane.YES_OPTION ) {
for(int i=0;i collection = new ArrayList();
ArrayList lastCollection = new ArrayList();
String lastCols[] = new String[0];
DbDatum datum = db.get_property("Astor", "LastCollections");
if (!datum.is_empty())
lastCols = datum.extractStringArray();
for (int i = 0; i < arg.svalue.length; i++) {
if (JiveUtils.isInsideArray(arg.svalue[i], lastCols) < 0)
collection.add(arg.svalue[i]);
else
lastCollection.add(arg.svalue[i]);
}
Collections.sort(collection);
Collections.sort(lastCollection);
collection.addAll(lastCollection);
for (int i = 0; i < collection.size(); i++)
add(new CollectionNode(collection.get(i)));
}
public String toString() {
return "Collection:";
}
void execAction(int number,boolean allowMultiple) {
}
}
// ---------------------------------------------------------------
class CollectionNode extends TangoNode {
private String collection;
CollectionNode(String collection) {
this.collection = collection;
}
void populateNode() throws DevFailed {
// Get host collection list
DeviceData argin = new DeviceData();
String request = "select distinct device from property_device where device like '" +
JiveUtils.getStarterDeviceHeader() + "%' and name='HostCollection' and value='" + collection + "'";
argin.insert(request);
DeviceData argout = db.command_inout("DbMySqlSelect", argin);
DevVarLongStringArray arg = argout.extractLongStringArray();
for (int i = 0; i < arg.svalue.length; i++) {
String s = arg.svalue[i];
add(new HostNode(collection,s.substring(s.lastIndexOf('/') + 1)));
}
}
public String getValue() {
StringBuffer retStr = new StringBuffer();
int count = getChildCount();
for(int i=0;i allHS = new ArrayList();
for(int level:allLevels) {
ArrayList servers = new ArrayList();
for(int i=0;i0 && !arg[i].toLowerCase().contains("starter")) allHS.add(arg[i]);
}
if(servers.size()>0)
add(new LevelNode(collection,host,level,servers));
}
allHostServers = new String[allHS.size()];
for(int i=0;i0) {
result.append("");
result.append(hostInfo);
result.append("\n\n");
}
int count = getChildCount();
for(int i=0;i"+l.toString()+"\n");
result.append("
\n");
result.append(l.getValue(true));
result.append("\n");
}
return result.toString();
}
public String getDisplayValue() {
if(hostUsage.length()>0)
return toString() + " (" + hostUsage + ")";
else
return toString();
}
public String toString() {
return host;
}
ImageIcon getIcon() {
return TangoNodeRenderer.hostsmallicon;
}
Action[] getAction() {
return new Action[] {
TreePanel.getAction(ACTION_START_HOST),
TreePanel.getAction(ACTION_STOP_HOST),
TreePanel.getAction(ACTION_CH_HOST_USAGE),
TreePanel.getAction(ACTION_GO_TO_STATER),
TreePanel.getAction(ACTION_NEW_SERVERS),
TreePanel.getAction(ACTION_TERMINAL),
TreePanel.getAction(ACTION_UNEXPORT_HOST)
};
}
void execAction(int actionNumber,boolean multipleCall) {
int ok;
switch (actionNumber) {
// ----------------------------------------------------------------------------
case ACTION_START_HOST:
ok = JOptionPane.showConfirmDialog(invoker, "Start all servers on " + host + " ?", "Confirmation", JOptionPane.YES_NO_OPTION);
if (ok == JOptionPane.YES_OPTION) {
try {
startServers(starter, allHostServers);
} catch (DevFailed e) {
JiveUtils.showTangoError(e);
}
}
break;
// ----------------------------------------------------------------------------
case ACTION_STOP_HOST:
ok = JOptionPane.showConfirmDialog(invoker, "Stop all servers on " + host + "?", "Confirmation", JOptionPane.YES_NO_OPTION);
if (ok == JOptionPane.YES_OPTION) {
try {
stopServers(starter, allHostServers);
refreshValues();
} catch (DevFailed e) {
JiveUtils.showTangoError(e);
}
}
break;
// ----------------------------------------------------------------------------
case ACTION_CH_HOST_USAGE:
String newUsage = JOptionPane.showInputDialog(invoker,"Host Usage",hostUsage);
if (newUsage != null) {
try {
DbDatum datum = new DbDatum("HostUsage",newUsage);
db.put_device_property(starterName,new DbDatum[]{datum});
refresh();
} catch (DevFailed e) {
JiveUtils.showTangoError(e);
}
}
break;
// ----------------------------------------------------------------------------
case ACTION_GO_TO_STATER:
invoker.goToServerNode("Starter/"+host);
break;
// ----------------------------------------------------------------------------
case ACTION_NEW_SERVERS:
StartServerDlg dlg = new StartServerDlg(db,host,starter,invoker);
try {
dlg.setServerList(db.get_server_list());
ATKGraphicsUtils.centerFrameOnScreen(dlg);
dlg.setVisible(true);
} catch (DevFailed e) {
JiveUtils.showTangoError(e);
}
break;
// ----------------------------------------------------------------------------
case ACTION_TERMINAL:
JSSHTerminal.MainPanel terminal;
String defaultUser = null;
String defaultPassword = null;
try {
DbDatum dd = db.get_property("Astor","RloginUser");
if(!dd.is_empty())
defaultUser = dd.extractString();
dd = db.get_property("Astor","RloginPassword");
if(!dd.is_empty())
defaultPassword = dd.extractString();
} catch (DevFailed e) {}
if(defaultUser!=null) {
terminal = new JSSHTerminal.MainPanel(host,defaultUser,defaultPassword,80,24,500);
terminal.setX11Forwarding(true);
terminal.setExitOnClose(false);
ATKGraphicsUtils.centerFrameOnScreen(terminal);
terminal.setVisible(true);
} else {
JiveUtils.showJiveError("No username !\nAStor/RloginUser free property not defined.");
}
break;
// ----------------------------------------------------------------------------
case ACTION_UNEXPORT_HOST:
try {
DeviceData argin = new DeviceData();
argin.insert(host);
DeviceData argout = db.command_inout("DbGetHostServersInfo", argin);
String[] arg = argout.extractStringArray();
ok = JOptionPane.showConfirmDialog(invoker, "Unexport all devices on " + host + " (" +
arg.length/3 + " servers)?", "Confirmation", JOptionPane.YES_NO_OPTION);
if (ok == JOptionPane.YES_OPTION) {
for (int i = 0; i < arg.length; i += 3) {
String srvName = arg[i];
db.unexport_server(srvName);
}
refreshValues();
}
} catch (DevFailed e) {
JiveUtils.showTangoError(e);
}
break;
}
}
}
// ---------------------------------------------------------------
class LevelNode extends TangoNode {
private String collection;
private String host;
private int level;
private String[] allServers;
LevelNode(String collection,String host,int level,ArrayList servers) {
this.host = host;
this.collection = collection;
this.level = level;
allServers = new String[servers.size()];
for(int i=0;i " + e.errors[i].desc + "\n";
result += bStr + "Reason -> " + e.errors[i].reason + "\n";
result += bStr + "Origin -> " + e.errors[i].origin + "\n";
}
}
return result;
}
String getValue() {
return getValue(false);
}
ImageIcon getIcon() {
return TangoNodeRenderer.levelicon;
}
Action[] getAction() {
return new Action[] {
TreePanel.getAction(ACTION_START_LEVEL),
TreePanel.getAction(ACTION_STOP_LEVEL)
};
}
void execAction(int actionNumber,boolean multipleCall) {
int ok;
switch (actionNumber) {
// ----------------------------------------------------------------------------
case ACTION_START_LEVEL:
ok = JOptionPane.showConfirmDialog(invoker, "Start level " + level + " on " + host + " ?", "Confirmation", JOptionPane.YES_NO_OPTION);
if (ok == JOptionPane.YES_OPTION) {
try {
startServers(getStarter(), allServers);
} catch (DevFailed e) {
JiveUtils.showTangoError(e);
}
}
break;
// ----------------------------------------------------------------------------
case ACTION_STOP_LEVEL:
ok = JOptionPane.showConfirmDialog(invoker, "Stop level " + level + " on " + host + "?", "Confirmation", JOptionPane.YES_NO_OPTION);
if (ok == JOptionPane.YES_OPTION) {
try {
stopServers(getStarter(), allServers);
refreshValues();
} catch (DevFailed e) {
JiveUtils.showTangoError(e);
}
}
break;
}
}
}
// ---------------------------------------------------------------
class ServerNode extends TangoNode implements IServerAction {
private String collection;
private String host;
private int level;
private String server;
ServerNode(String collection,String host,int level,String server) {
this.server = server;
this.host = host;
this.level = level;
this.collection = collection;
}
DeviceProxy getStarter() {
return ((LevelNode)getParent()).getStarter();
}
void populateNode() throws DevFailed {
String[] srvList = null;
String[] dbList = null;
int i;
try {
// Try to get class list through the admin device
String admName = "dserver/" + server;
DeviceProxy adm = new DeviceProxy(admName);
DeviceData datum = adm.command_inout("QueryClass");
srvList = datum.extractStringArray();
} catch (DevFailed e) {}
// Get the list from the database
dbList = db.get_server_class_list(server);
if(srvList!=null) {
// Add actual class
for (i = 0; i < srvList.length; i++)
add(new ClassNode(collection,host,level,server,srvList[i]));
// No add other class found in database as invalid
for (i = 0; i < dbList.length; i++) {
if(!JiveUtils.contains(srvList,dbList[i])) {
add(new ClassNode(collection,host,level,server,dbList[i]));
}
}
} else {
// Old fashion
for (i = 0; i < dbList.length; i++)
add(new ClassNode(collection,host,level,server,dbList[i]));
}
}
String getTitle() {
return "Server Info";
}
public String toString() {
return server;
}
ImageIcon getIcon() {
return TangoNodeRenderer.srvicon;
}
DevState getState() throws DevFailed {
return getServerState(getStarter(),new String[]{server})[0];
}
String getValue() {
String result = "";
if(getStarter()==null)
return result;
try {
DevState serverState = getState();
result = server + ": " + getServerStateString(serverState) + "\n";
result += "-- Log ------------------------------\n";
DeviceData argin = new DeviceData();
argin.insert(server);
DeviceData argout = getStarter().command_inout("DevReadLog",argin);
result += argout.extractString();
} catch (DevFailed e) {
for (int i = 0; i < e.errors.length; i++) {
result += "Desc -> " + e.errors[i].desc + "\n";
result += "Reason -> " + e.errors[i].reason + "\n";
result += "Origin -> " + e.errors[i].origin + "\n";
}
}
return result;
}
Action[] getAction() {
if (JiveUtils.readOnly)
return new Action[0];
else
return new Action[]{
TreePanel.getAction(ACTION_DELETE),
TreePanel.getAction(ACTION_ADDCLASS),
TreePanel.getAction(ACTION_TESTADMIN),
TreePanel.getAction(ACTION_SAVESERVER),
TreePanel.getAction(ACTION_CLASSWIZ),
TreePanel.getAction(ACTION_UNEXPORT),
TreePanel.getAction(ACTION_DEV_DEPEND),
TreePanel.getAction(ACTION_THREAD_POLL),
TreePanel.getAction(ACTION_MOVE_SERVER),
TreePanel.getAction(ACTION_RESTART_SERVER),
TreePanel.getAction(ACTION_START_SERVER),
TreePanel.getAction(ACTION_STOP_SERVER),
TreePanel.getAction(ACTION_CH_LEVEL)
};
}
void execAction(int actionNumber,boolean multipleCall) throws IOException {
int ok;
switch(actionNumber) {
// ----------------------------------------------------------------------------
case ACTION_DELETE:
if(multipleCall) {
try {
db.delete_server(server);
} catch (DevFailed e) {
throw new IOException(server + ":" + e.errors[0].desc);
}
} else {
ok = JOptionPane.showConfirmDialog(invoker, "Delete server " + server + " ?", "Confirm delete", JOptionPane.YES_NO_OPTION);
if (ok == JOptionPane.YES_OPTION) {
try {
db.delete_server(server);
} catch (DevFailed e) {
JiveUtils.showTangoError(e);
}
refresh();
selectHost(collection,host);
}
}
break;
// ----------------------------------------------------------------------------
case ACTION_ADDCLASS:
ServerDlg sdlg = new ServerDlg(this);
sdlg.setClassList(invoker.getClassTreePanel().getClassList());
sdlg.setValidFields(false, true);
sdlg.setDefaults(server, "");
ATKGraphicsUtils.centerFrame(invoker.innerPanel, sdlg);
sdlg.setVisible(true);
break;
// ----------------------------------------------------------------------------
case ACTION_TESTADMIN:
testDevice("dserver/" + server);
break;
// ----------------------------------------------------------------------------
case ACTION_SAVESERVER:
if(multipleCall) {
saveServerData(TreePanel.globalResFile,server);
} else {
FileWriter resFile;
File file = TreePanel.getSaveFile(invoker);
if( file!=null ) {
try {
resFile = new FileWriter(file.getAbsolutePath());
Date date = new Date(System.currentTimeMillis());
resFile.write("#\n# Resource backup , created " + date + "\n#\n\n");
saveServerData(resFile,server);
resFile.close();
} catch (IOException e) {
JiveUtils.showJiveError("Failed to create resource file !\n" + e.getMessage());
}
}
}
break;
// ----------------------------------------------------------------------------
case TreePanel.ACTION_CLASSWIZ:
DevWizard cwdlg = new DevWizard(invoker);
cwdlg.showClassesWizard(server);
refresh();
break;
// ----------------------------------------------------------------------------
case TreePanel.ACTION_UNEXPORT:
ok = JOptionPane.showConfirmDialog(invoker, "This will unexport all devices of " + server + "\n Do you want to continue ?", "Confirm unexport device", JOptionPane.YES_NO_OPTION);
if (ok == JOptionPane.YES_OPTION) {
try {
//System.out.println(" Unexport device of" + srvName);
db.unexport_server(server);
} catch (DevFailed e) {
JiveUtils.showTangoError(e);
}
}
break;
// ----------------------------------------------------------------------------
case ACTION_DEV_DEPEND:
launchDevDepend(server);
break;
// ----------------------------------------------------------------------------
case ACTION_THREAD_POLL:
launchPollingThreadsManager(server);
break;
// ----------------------------------------------------------------------------
case ACTION_MOVE_SERVER:
// Rename a server
String newSName = JOptionPane.showInputDialog(null,"Rename server",server);
if(newSName==null) return;
try {
db.rename_server(server,newSName);
refresh();
selectServer(collection, host, level, newSName);
} catch (DevFailed e) {
JiveUtils.showTangoError(e);
}
break;
// ----------------------------------------------------------------------------
case ACTION_RESTART_SERVER:
// Restart a controlled server
try {
if(getStarter()!=null) {
stopServer(getStarter(), server);
startServer(getStarter(), server);
}
} catch (DevFailed e) {
JiveUtils.showTangoError(e);
}
break;
// ----------------------------------------------------------------------------
case ACTION_START_SERVER:
// Start a controlled server
try {
if(getStarter()!=null)
startServer(getStarter(), server);
} catch (DevFailed e) {
JiveUtils.showTangoError(e);
}
break;
// ----------------------------------------------------------------------------
case ACTION_STOP_SERVER:
// Stop a controlled server
try {
if(getStarter()!=null)
stopServer(getStarter(), server);
} catch (DevFailed e) {
JiveUtils.showTangoError(e);
}
refreshValues();
break;
// ----------------------------------------------------------------------------
case ACTION_CH_LEVEL:
DbServer dbs;
DbServInfo info = null;
try {
dbs = new DbServer(server);
info = dbs.get_info();
} catch (DevFailed e) {
JiveUtils.showTangoError(e);
return;
}
ServerInfoDlg dlg = new ServerInfoDlg(invoker);
if (dlg.showDialog(info) == ServerInfoDlg.RET_OK) {
try {
info = dlg.getSelection();
if (info != null) {
info.host = host;
if (info.startup_level == 0)
info.controlled = false;
dbs.put_info(info);
refresh();
selectServer(collection, host, info.startup_level, server);
} else {
// Check if Server is stopped
if (getState() == DevState.ON) {
JiveUtils.showJiveError("Stop " + server + " Server before !");
return;
}
// Remove Server info in database
dbs.put_info(new DbServInfo(server, host, false, 0));
// Register devices on empty host and un export.
String[] deviceName = dbs.get_device_class_list();
for (int i = 0; i < deviceName.length; i += 2) {
db.export_device(new DbDevExportInfo(deviceName[i], "", "", ""));
db.unexport_device(deviceName[i]);
}
refresh();
selectHost(collection, host);
}
} catch (DevFailed e) {
JiveUtils.showTangoError(e);
}
}
break;
}
}
// IServerAction (Call by ServerDlg)
public void doJob(String server, String classname, String[] devices) {
// Add devices
try {
for (int i = 0; i < devices.length; i++)
db.add_device(devices[i], classname, server);
} catch (DevFailed e) {
JiveUtils.showTangoError(e);
}
refresh();
selectClass(collection,host,level,server,classname);
}
}
// ---------------------------------------------------------------
class ClassNode extends TangoNode implements IServerAction {
private String collection;
private String host;
private int level;
private String server;
private String className;
private String[] devList = new String[0];
ClassNode(String collection,String host,int level,String server,String className) {
this.collection = collection;
this.host = host;
this.level = level;
this.server = server;
this.className = className;
try {
devList = db.get_device_name(server , className);
} catch (DevFailed e) {}
}
void populateNode() throws DevFailed {
for (int i = 0; i < devList.length; i++)
add(new DeviceServerNode(collection,host,level,server,className,devList[i]));
}
public boolean isLeaf() {
return devList.length == 0;
}
ImageIcon getIcon() {
if(devList.length==0)
return TangoNodeRenderer.uclassicon;
else
return TangoNodeRenderer.classicon;
}
public String toString() {
return className;
}
Action[] getAction() {
if(JiveUtils.readOnly)
return new Action[0];
else
return new Action[]{
TreePanel.getAction(ACTION_RENAME),
TreePanel.getAction(ACTION_DELETE),
TreePanel.getAction(ACTION_ADDDEVICE),
TreePanel.getAction(ACTION_DEVICESWIZ)
};
}
void execAction(int actionNumber,boolean multipleCall) throws IOException {
switch(actionNumber) {
// ----------------------------------------------------------------------------
case ACTION_RENAME:
// Rename a class
String newName = JOptionPane.showInputDialog(null,"Rename class",className);
if(newName==null) return;
if(searchNode((TangoNode)getParent(),newName)!=null) {
JiveUtils.showJiveError("Name already exists.");
return;
}
for(int i=0;i 0) {
DbDatum[] data = db.get_device_property(devName, propList);
db.put_device_property(nDevName, data);
}
// Clone attributes properties
try {
String[] attList = db.get_device_attribute_list(devName);
if (attList.length > 0) {
DbAttribute[] adata = db.get_device_attribute_property(devName, attList);
db.put_device_attribute_property(nDevName, adata);
}
} catch (DevFailed e3) {
JiveUtils.showJiveError("Failed to copy attribute properties of " + devName + "\n" + e3.errors[0].desc);
}
}
// Remove the old device
if(isAlive)
JiveUtils.showJiveWarning("The old device " + devName + " is still alive and should be removed by hand.");
else
db.delete_device(devName);
} catch (DevFailed e4) {
JiveUtils.showTangoError(e4);
}
}
return success;
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy