void setConfig(Configuration config) {
log.debug("config: " + config);
proxyHost = config.get(PARAM_PROXY_HOST);
proxyPort = config.getInt(PARAM_PROXY_PORT, DEFAULT_PROXY_PORT);
if (StringUtil.isNullString(proxyHost) || proxyPort <= 0) {
String http_proxy = System.getenv("http_proxy");
if (!StringUtil.isNullString(http_proxy)) {
try {
HostPortParser hpp = new HostPortParser(http_proxy);
proxyHost = hpp.getHost();
proxyPort = hpp.getPort();
} catch (HostPortParser.InvalidSpec e) {
log.warning("Can't parse http_proxy environment var, ignoring: " + http_proxy + ": " + e);
}
}
}
if (StringUtil.isNullString(proxyHost) || proxyPort <= 0) {
proxyHost = null;
} else {
log.info("Proxying through " + proxyHost + ":" + proxyPort);
}
userAgent = config.get(PARAM_USER_AGENT);
if (StringUtil.isNullString(userAgent)) {
userAgent = null;
} else {
log.debug("Setting User-Agent to " + userAgent);
}
}
public int match(String url) {
if (StringUtil.equalStringsIgnoreCase(url, m_registryUrl)
|| StringUtil.endsWithIgnoreCase(url, ".jar")) {
return CrawlRule.INCLUDE;
} else {
return CrawlRule.EXCLUDE;
}
}
/** Concatenate params for URL string */
static String concatParams(String p1, String p2) {
if (StringUtil.isNullString(p1)) {
return p2;
}
if (StringUtil.isNullString(p2)) {
return p1;
}
return p1 + "&" + p2;
}
/**
* Did the client provide the minimal parameters required?
*
* @return true If so
*/
private boolean verifyMinimumParameters() {
int count = 0;
if (!StringUtil.isNullString(getParameter(AP_E_PUBLICATION))) count++;
if (!StringUtil.isNullString(getParameter(AP_E_CLASSNAME))) count++;
if (!StringUtil.isNullString(getParameter(AP_E_PLUGIN))) count++;
return (count > 0);
}
private static void appendHTML(JEditorPane editor, String html) {
try {
html = StringUtil.replaceAll(html, "\t", " ");
html = StringUtil.replaceAll(html, "\r\n", "\n");
html = StringUtil.replaceAll(html, "\r", "");
Vector vt = StringUtil.toStringVector(html, "\n");
HTMLEditorKit kit = (HTMLEditorKit) editor.getEditorKit();
HTMLDocument doc = (HTMLDocument) editor.getDocument();
for (int iIndex = 0; iIndex < vt.size(); iIndex++)
kit.insertHTML(doc, doc.getLength(), (String) vt.elementAt(iIndex), 0, 0, null);
} catch (Exception e) {
e.printStackTrace();
}
}
/** Concatenate params for URL string */
String concatParams(Properties props) {
if (props == null) {
return null;
}
java.util.List list = new ArrayList();
for (Iterator iter = props.keySet().iterator(); iter.hasNext(); ) {
String key = (String) iter.next();
String val = props.getProperty(key);
if (!StringUtil.isNullString(val)) {
list.add(key + "=" + urlEncode(val));
}
}
return StringUtil.separatedString(list, "&");
}
protected Properties filterResponseProps(Properties props) {
Properties res = new Properties();
for (Map.Entry ent : props.entrySet()) {
String key = (String) ent.getKey();
if (StringUtil.startsWithIgnoreCase(key, "x-lockss")
|| StringUtil.startsWithIgnoreCase(key, "x_lockss")
|| key.equalsIgnoreCase("org.lockss.version.number")) {
continue;
}
// We've lost the original case - capitalize them the way most people
// expect
res.put(StringUtil.titleCase(key, '-'), (String) ent.getValue());
}
return res;
}
protected void logParams() {
Enumeration en = req.getParameterNames();
while (en.hasMoreElements()) {
String name = (String) en.nextElement();
String vals[];
String dispval;
if (StringUtil.indexOfIgnoreCase(name, "passw") >= 0) {
dispval = req.getParameter(name).length() == 0 ? "" : "********";
} else if (log.isDebug2() && (vals = req.getParameterValues(name)).length > 1) {
dispval = StringUtil.separatedString(vals, ", ");
} else {
dispval = req.getParameter(name);
}
log.debug(name + " = " + dispval);
}
}
/**
* A target system is required to create an AU - was it provided?
*
* @return true If at least one target was specified
*/
private boolean verifyTarget() {
if (!isCreateCommand()) {
return true;
}
return !StringUtil.isNullString(getParameter(AP_E_TARGET));
}
/**
* Return the archive file type corresponding to the filename extension in the URL, or null if
* none.
*/
public String getFromUrl(String url) throws MalformedURLException {
if (StringUtil.endsWithIgnoreCase(url, ".tar.gz")) {
return getExtMimeMap().get(".tar.gz");
}
String ext = UrlUtil.getFileExtension(url).toLowerCase();
return getExtMimeMap().get("." + ext);
}
/**
* Escapes instances of File.separator from the query. These are safe from filename overlap, but
* can't convert into extended paths and directories.
*
* @param query the query
* @return the escaped query
*/
static String escapeQuery(String query) {
if (query.indexOf(File.separator) >= 0) {
return StringUtil.replaceString(query, File.separator, ESCAPE_STR + ENCODED_SEPARATOR_CHAR);
} else {
return query;
}
}
/**
* Escapes instances of the ESCAPE_CHAR from the path. This avoids name conflicts with the
* repository files, such as '#nodestate.xml'.
*
* @param path the path
* @return the escaped path
*/
static String escapePath(String path) {
// XXX escaping disabled because of URL encoding
if (false && path.indexOf(ESCAPE_CHAR) >= 0) {
return StringUtil.replaceString(path, ESCAPE_STR, ESCAPE_STR + ESCAPE_STR);
} else {
return path;
}
}
/**
* Add javascript to page. Normally adds a link to the script file, but can be told to include the
* script directly in the page, to accomodate unit testing of individual servlets, when other
* fetches won't work.
*/
protected void addJavaScript(Composite comp) {
String include = (String) context.getAttribute(ATTR_INCLUDE_SCRIPT);
if (StringUtil.isNullString(include)) {
linkToJavaScript(comp);
} else {
includeJavaScript0(comp);
}
}
/**
* mapUrlToFileLocation() is the method used to resolve urls into file names. This maps a given
* url to a file location, using the au top directory as the base. It creates directories which
* mirror the html string, so 'http://www.journal.org/issue1/index.html' would be cached in the
* file: <rootLocation>/www.journal.org/http/issue1/index.html
*
* @param rootLocation the top directory for ArchivalUnit this URL is in
* @param urlStr the url to translate
* @return the url file location
* @throws java.net.MalformedURLException
*/
public static String mapUrlToFileLocation(String rootLocation, String urlStr)
throws MalformedURLException {
int totalLength = rootLocation.length() + urlStr.length();
URL url = new URL(urlStr);
StringBuilder buffer = new StringBuilder(totalLength);
buffer.append(rootLocation);
if (!rootLocation.endsWith(File.separator)) {
buffer.append(File.separator);
}
buffer.append(url.getHost().toLowerCase());
int port = url.getPort();
if (port != -1) {
buffer.append(PORT_SEPARATOR);
buffer.append(port);
}
buffer.append(File.separator);
buffer.append(url.getProtocol());
if (RepositoryManager.isEnableLongComponents()) {
String escapedPath =
escapePath(
StringUtil.replaceString(url.getPath(), UrlUtil.URL_PATH_SEPARATOR, File.separator));
String query = url.getQuery();
if (query != null) {
escapedPath = escapedPath + "?" + escapeQuery(query);
}
String encodedPath = RepositoryNodeImpl.encodeUrl(escapedPath);
// encodeUrl strips leading / from path
buffer.append(File.separator);
buffer.append(encodedPath);
} else {
buffer.append(
escapePath(
StringUtil.replaceString(url.getPath(), UrlUtil.URL_PATH_SEPARATOR, File.separator)));
String query = url.getQuery();
if (query != null) {
buffer.append("?");
buffer.append(escapeQuery(query));
}
}
return buffer.toString();
}
/**
* Return a (possibly labelled) checkbox.
*
* @param label appears to right of checkbox if non null
* @param value value included in result set if box checked
* @param key form key to which result set is assigned
* @param checked if true, box is initially checked
* @return a checkbox Element
*/
Element checkBox(String label, String value, String key, boolean checked) {
Input in = new Input(Input.Checkbox, key, value);
if (checked) {
in.check();
}
setTabOrder(in);
if (StringUtil.isNullString(label)) {
return in;
} else {
Composite c = new Composite();
c.add(in);
c.add(" ");
c.add(label);
return c;
}
}
private static synchronized String getJavascript() {
if (jstext == null) {
InputStream istr = null;
try {
ClassLoader loader = Thread.currentThread().getContextClassLoader();
istr = loader.getResourceAsStream(JAVASCRIPT_RESOURCE);
jstext = StringUtil.fromInputStream(istr);
istr.close();
} catch (Exception e) {
log.error("Can't load javascript", e);
} finally {
IOUtil.safeClose(istr);
}
}
return jstext;
}
/**
* Used to write Resources for a Subject. Resources will use "ObjectNode" method.
*
* @param predicate PredicateNode
* @param object Literal
* @param writer PrintWriter
* @throws GraphException
*/
protected void writeStatement(
Graph graph, SubjectNode subject, PredicateNode predicate, Literal object, PrintWriter writer)
throws GraphException {
// determine if the Literal has a datatype
URI datatype = object.getDatatypeURI();
// Get the lexical form of the literal
String literalObject = object.getLexicalForm();
// Create the StringBuffer to hold the resultant string
StringBuffer buffer = new StringBuffer();
// Escape the XML string
StringUtil.quoteAV(literalObject, buffer);
if (datatype != null) {
// write as: <predicateURI rdf:datatype="datatype">"Literal value"
// </predicateURI>
writer.println(
" <"
+ this.getURI(predicate)
+ " "
+ RDF_PREFIX
+ ":datatype=\""
+ datatype
+ "\">"
+ buffer.toString()
+ "</"
+ this.getURI(predicate)
+ ">");
} else {
// write as: <predicateURI>"Literal value"</predicateURI>
writer.println(
" <"
+ this.getURI(predicate)
+ ">"
+ buffer.toString()
+ "</"
+ this.getURI(predicate)
+ ">");
}
}
/**
* Are all of the "defining parameters" required to create an AU available?
*
* @return true If so
*/
private boolean verifyDefiningParameters() {
KeyedList parameters;
int size;
if (!isCreateCommand()) {
return true;
}
parameters = ParseUtils.getDynamicFields(getXmlUtils(), getRequestDocument(), AP_MD_AUDEFINING);
size = parameters.size();
for (int i = 0; i < size; i++) {
if (StringUtil.isNullString((String) parameters.getValue(i))) {
return false;
}
}
return true;
}
void checkParamAgreement(String key, PrintfContext context) {
List<String> printfList = getElementList(key);
if (printfList == null) {
return;
}
for (String printf : printfList) {
if (StringUtil.isNullString(printf)) {
log.warning("Null printf string in " + key);
continue;
}
PrintfUtil.PrintfData p_data = PrintfUtil.stringToPrintf(printf);
Collection<String> p_args = p_data.getArguments();
for (String arg : p_args) {
ConfigParamDescr descr = findAuConfigDescr(arg);
if (descr == null) {
throw new PluginException.InvalidDefinition(
"Not a declared parameter: " + arg + " in " + printf + " in " + getPluginName());
}
// ensure range and set params used only in legal context
switch (context) {
case Regexp:
case Display:
// everything is legal in a regexp or a display string
break;
case URL:
// NUM_RANGE and SET legal because can enumerate. Can't
// enumerate RANGE
switch (descr.getType()) {
case ConfigParamDescr.TYPE_RANGE:
throw new PluginException.InvalidDefinition(
"Range parameter ("
+ arg
+ ") used in illegal context in "
+ getPluginName()
+ ": "
+ key
+ ": "
+ printf);
default:
}
}
}
}
}
/** If in testing mode FOO, copy values from FOO_override map, if any, to main map */
void processOverrides(TypedEntryMap map) {
String testMode = getTestingMode();
if (StringUtil.isNullString(testMode)) {
return;
}
Object o = map.getMapElement(testMode + DefinableArchivalUnit.SUFFIX_OVERRIDE);
if (o == null) {
return;
}
if (o instanceof Map) {
Map overrideMap = (Map) o;
for (Map.Entry entry : (Set<Map.Entry>) overrideMap.entrySet()) {
String key = (String) entry.getKey();
Object val = entry.getValue();
log.debug(getDefaultPluginName() + ": Overriding " + key + " with " + val);
map.setMapElement(key, val);
}
}
}
public void loadAuConfigDescrs(Configuration config) throws ConfigurationException {
super.loadAuConfigDescrs(config);
this.m_registryUrl = config.get(ConfigParamDescr.BASE_URL.getKey());
// Now we can construct a valid CC permission checker.
m_permissionCheckers =
// ListUtil.list(new CreativeCommonsPermissionChecker(m_registryUrl));
ListUtil.list(new CreativeCommonsPermissionChecker());
paramMap.putLong(
KEY_AU_NEW_CONTENT_CRAWL_INTERVAL,
CurrentConfig.getTimeIntervalParam(
PARAM_REGISTRY_CRAWL_INTERVAL, DEFAULT_REGISTRY_CRAWL_INTERVAL));
if (log.isDebug2()) {
log.debug2(
"Setting Registry AU recrawl interval to "
+ StringUtil.timeIntervalToString(
paramMap.getLong(KEY_AU_NEW_CONTENT_CRAWL_INTERVAL)));
}
}
public void lockssRun() {
setPriority(PRIORITY_PARAM_SIZE_CALC, PRIORITY_DEFAULT_SIZE_CALC);
startWDog(WDOG_PARAM_SIZE_CALC, WDOG_DEFAULT_SIZE_CALC);
triggerWDogOnExit(true);
nowRunning();
while (goOn) {
try {
pokeWDog();
if (sizeCalcQueue.isEmpty()) {
Deadline timeout = Deadline.in(Constants.HOUR);
sizeCalcSem.take(timeout);
}
RepositoryNode node;
synchronized (sizeCalcQueue) {
node = (RepositoryNode) CollectionUtil.getAnElement(sizeCalcQueue);
}
if (node != null) {
long start = TimeBase.nowMs();
log.debug2("CalcSize start: " + node);
long dur = 0;
try {
doSizeCalc(node);
dur = TimeBase.nowMs() - start;
log.debug2("CalcSize finish (" + StringUtil.timeIntervalToString(dur) + "): " + node);
} catch (RuntimeException e) {
log.warning("doSizeCalc: " + node, e);
}
synchronized (sizeCalcQueue) {
sizeCalcQueue.remove(node);
}
pokeWDog();
long sleep = sleepTimeToAchieveLoad(dur, sizeCalcMaxLoad);
Deadline.in(sleep).sleep();
}
} catch (InterruptedException e) {
// just wakeup and check for exit
}
}
if (!goOn) {
triggerWDogOnExit(false);
}
}
public void testCreateSharedPLNKeyStores() throws Exception {
List<String> hosts = ListUtil.list("host1", "host2.foo.bar", "host3");
List<String> hosts2 = ListUtil.list("host3", "host4");
File dir = getTempDir();
File pub = new File(dir, "pub.ks");
KeyStoreUtil.createSharedPLNKeyStores(
dir, hosts, pub, "pubpass", MiscTestUtil.getSecureRandom());
assertPubKs(pub, "pubpass", hosts);
for (String host : hosts) {
assertPrivateKs(
new File(dir, host + ".jceks"), StringUtil.fromFile(new File(dir, host + ".pass")), host);
}
KeyStore pubks1 = loadKeyStore("jceks", new File(dir, "pub.ks"), "pubpass");
Certificate host1cert1 = pubks1.getCertificate("host1.crt");
Certificate host3cert1 = pubks1.getCertificate("host3.crt");
String host1priv1 = StringUtil.fromFile(new File(dir, "host1.jceks"));
String host3priv1 = StringUtil.fromFile(new File(dir, "host3.jceks"));
// Now add host4 and generate a new key for host3
KeyStoreUtil.createSharedPLNKeyStores(
dir, hosts2, pub, "pubpass", MiscTestUtil.getSecureRandom());
List<String> both = ListUtils.sum(hosts, hosts2);
assertPubKs(pub, "pubpass", both);
for (String host : both) {
assertPrivateKs(
new File(dir, host + ".jceks"), StringUtil.fromFile(new File(dir, host + ".pass")), host);
}
KeyStore pubks2 = loadKeyStore("jceks", new File(dir, "pub.ks"), "pubpass");
// host1 should have the same cert, host3 not
Certificate host1cert2 = pubks2.getCertificate("host1.crt");
Certificate host3cert2 = pubks2.getCertificate("host3.crt");
assertEquals(host1cert1, host1cert2);
assertNotEquals(host3cert1, host3cert2);
// host1's private key file should be the same, host3's not
String host1priv2 = StringUtil.fromFile(new File(dir, "host1.jceks"));
String host3priv2 = StringUtil.fromFile(new File(dir, "host3.jceks"));
assertEquals(host1priv1, host1priv2);
assertNotEquals(host3priv1, host3priv2);
}
/** Query the daemon for information required to set up this command */
private boolean commandSetup() {
Configuration configuration = null;
Collection noEditKeys = null;
String key;
String value;
/*
* Configure a well known publication?
*/
if ((value = getParameter(AP_E_PUBLICATION)) != null) {
PluginProxy plugin = getTitlePlugin(value);
/*
* Set plugin and Title configuration information
*/
if (plugin == null) {
String message = "Unknown Publication:" + value;
log.warning(message);
return error(message);
}
setPlugin(plugin);
setTitleConfig(plugin.getTitleConfig(value));
configuration = getTitleConfig().getConfig();
noEditKeys = getNoEditKeys();
} else {
/*
* Lookup by Plugin or Class name - set the plugin
*
* NB: As of 23-Feb-04, this is not supported from AddAuPage.java. See
* AddAuWithCompleteFunctionalityPage.java for full support.
*/
if ((value = getParameter(AP_E_PLUGIN)) != null) {
key = RemoteApi.pluginKeyFromId(value);
} else if ((value = getParameter(AP_E_CLASSNAME)) != null) {
key = RemoteApi.pluginKeyFromId(value);
} else {
return error("Supply a Publication, Plugin, or Class name");
}
if (StringUtil.isNullString(key)) {
return error("Supply a valid Publication, Plugin, or Class name");
}
if (!pluginLoaded(key)) {
return error("Plugin is not loaded: " + key);
}
setPlugin(getPluginProxy(key));
}
/*
* Finally, return an XML rendition of the Plugin and AU key set up
*/
generateSetupXml(configuration, noEditKeys);
return true;
}
private void jbInit() throws Exception {
////////////////////////////////////////////////////////
// Init LAF
////////////////////////////////////////////////////////
ButtonGroup grpLAF = new ButtonGroup();
ActionListener lsnLAF =
new ActionListener() {
public void actionPerformed(ActionEvent evt) {
int iIndex = mvtLAFItem.indexOf(evt.getSource());
if (iIndex >= 0) changeLAF(iIndex);
}
};
////////////////////////////////////////////////////////
UIManager.LookAndFeelInfo laf =
new UIManager.LookAndFeelInfo(
"Kunststoff", "com.incors.plaf.kunststoff.KunststoffLookAndFeel");
marrLaf = UIManager.getInstalledLookAndFeels();
int iIndex = 0;
while (iIndex < marrLaf.length && !marrLaf[iIndex].getName().equals(laf.getName())) iIndex++;
if (iIndex >= marrLaf.length) {
UIManager.installLookAndFeel(laf);
marrLaf = UIManager.getInstalledLookAndFeels();
}
for (iIndex = 0; iIndex < marrLaf.length; iIndex++) {
JMenuItem mnu = new JRadioButtonMenuItem(marrLaf[iIndex].getName());
mnu.addActionListener(lsnLAF);
mvtLAFItem.addElement(mnu);
mnuUI.add(mnu);
grpLAF.add(mnu);
}
mnuUI.addSeparator();
////////////////////////////////////////////////////////
// Init language
////////////////////////////////////////////////////////
ButtonGroup grpLanguage = new ButtonGroup();
ActionListener lsnLanguage =
new ActionListener() {
public void actionPerformed(ActionEvent e) {
int iIndex = mvtLanguageItem.indexOf(e.getSource());
if (iIndex >= 0) changeDictionary((String) mvtLanguage.elementAt(iIndex));
}
};
////////////////////////////////////////////////////////
String[] str = MonitorDictionary.getSupportedLanguage();
for (iIndex = 0; iIndex < str.length; iIndex++) {
JMenuItem mnu =
new JRadioButtonMenuItem(MonitorDictionary.getDictionary(str[iIndex]).getLanguage());
mnu.addActionListener(lsnLanguage);
mvtLanguage.addElement(str[iIndex]);
mvtLanguageItem.addElement(mnu);
mnuUI.add(mnu);
grpLanguage.add(mnu);
}
////////////////////////////////////////////////////////
// Add to main menu
////////////////////////////////////////////////////////
mnuMain.removeAll();
mnuMain.add(mnuSystem);
mnuSystem.add(mnuSystem_Login);
mnuSystem.add(mnuSystem_ChangePassword);
mnuSystem.addSeparator();
mnuSystem.add(mnuSystem_StopServer);
mnuSystem.add(mnuSystem_EnableThreads);
mnuMain.add(mnuUI);
mnuMain.add(mnuHelp);
mnuHelp.add(mnuHelp_About);
////////////////////////////////////////////////////////
mnuMain.add(chkVietnamese);
mnuMain.add(lblStatus);
////////////////////////////////////////////////////////
pnlThread.setTabPlacement(JTabbedPane.LEFT);
pnlThread.setTabLayoutPolicy(JTabbedPane.SCROLL_TAB_LAYOUT);
////////////////////////////////////////////////////////
tblUser.addColumn("", 1, false);
tblUser.addColumn("", 2, false, Global.FORMAT_DATE_TIME);
tblUser.addColumn("", 3, false);
////////////////////////////////////////////////////////
JPanel pnlMessage = new JPanel();
pnlMessage.setLayout(new GridBagLayout());
pnlMessage.add(
new JScrollPane(txtBoard),
new GridBagConstraints(
0,
0,
2,
1,
1.0,
1.0,
GridBagConstraints.CENTER,
GridBagConstraints.BOTH,
new Insets(2, 2, 2, 2),
0,
0));
pnlMessage.add(
txtMessage,
new GridBagConstraints(
0,
1,
1,
1,
1.0,
0.0,
GridBagConstraints.CENTER,
GridBagConstraints.BOTH,
new Insets(2, 2, 2, 2),
0,
0));
pnlMessage.add(
btnSend,
new GridBagConstraints(
1,
1,
1,
1,
0.0,
0.0,
GridBagConstraints.CENTER,
GridBagConstraints.NONE,
new Insets(2, 2, 2, 2),
0,
0));
txtBoard.setEditable(false);
txtBoard.setAutoscrolls(true);
txtBoard.setContentType("text/html");
clearAll(txtBoard);
////////////////////////////////////////////////////////
JPanel pnlUserButton = new JPanel(new GridLayout(1, 2, 4, 4));
pnlUserButton.add(btnKick);
pnlUserButton.add(btnRefresh);
////////////////////////////////////////////////////////
JPanel pnlManager = new JPanel(new GridBagLayout());
pnlManager.add(
new JScrollPane(tblUser),
new GridBagConstraints(
0,
0,
1,
1,
1.0,
1.0,
GridBagConstraints.CENTER,
GridBagConstraints.BOTH,
new Insets(2, 2, 2, 2),
0,
0));
pnlManager.add(
pnlUserButton,
new GridBagConstraints(
0,
1,
1,
1,
0.0,
0.0,
GridBagConstraints.CENTER,
GridBagConstraints.NONE,
new Insets(4, 2, 4, 2),
0,
0));
////////////////////////////////////////////////////////
pnlUser.setDividerLocation(320);
pnlUser.setLeftComponent(pnlManager);
pnlUser.setRightComponent(pnlMessage);
pnlUser.setOneTouchExpandable(true);
////////////////////////////////////////////////////////
setOrientation(JSplitPane.VERTICAL_SPLIT);
setOneTouchExpandable(true);
pnlThread.setVisible(false);
pnlUser.setVisible(false);
setTopComponent(pnlThread);
setBottomComponent(pnlUser);
////////////////////////////////////////////////////////
pmn.add(mnuSelectAll);
pmn.addSeparator();
pmn.add(mnuClearSelected);
pmn.add(mnuClearAll);
////////////////////////////////////////////////////////
setBorder(BorderFactory.createEmptyBorder());
pnlUser.setBorder(BorderFactory.createEmptyBorder());
pnlManager.setBorder(
BorderFactory.createBevelBorder(
javax.swing.border.BevelBorder.RAISED,
Color.white,
UIManager.getColor("Panel.background"),
UIManager.getColor("Panel.background"),
UIManager.getColor("Panel.background")));
pnlMessage.setBorder(
BorderFactory.createBevelBorder(
javax.swing.border.BevelBorder.RAISED,
Color.white,
UIManager.getColor("Panel.background"),
UIManager.getColor("Panel.background"),
UIManager.getColor("Panel.background")));
////////////////////////////////////////////////////////
Skin.applySkin(mnuMain);
Skin.applySkin(tblUser);
Skin.applySkin(pmn);
Skin.applySkin(this);
////////////////////////////////////////////////////////
// Default setting
////////////////////////////////////////////////////////
Hashtable prt = null;
try {
prt = Global.loadHashtable(Global.FILE_CONFIG);
} catch (Exception e) {
prt = new Hashtable();
}
changeLAF(Integer.parseInt(StringUtil.nvl(prt.get("LAF"), "0")));
changeDictionary(StringUtil.nvl(prt.get("Language"), "VN"));
Skin.LANGUAGE_CHANGE_LISTENER = this;
MonitorProcessor.setRootObject(this);
updateKeyboardUI();
////////////////////////////////////////////////////////
// Event handler
////////////////////////////////////////////////////////
tblUser.addMouseListener(
new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getClickCount() > 1) btnKick.doClick();
}
});
////////////////////////////////////////////////////////
btnRefresh.addActionListener(
new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent evt) {
try {
DDTP request = new DDTP();
request.setRequestID(String.valueOf(System.currentTimeMillis()));
DDTP response = channel.sendRequest("ThreadProcessor", "queryUserList", request);
if (response != null) {
tblUser.setData((Vector) response.getReturn());
if (mstrChannel != null) removeUser(mstrChannel);
}
} catch (Exception e) {
e.printStackTrace();
MessageBox.showMessageDialog(pnlThread, e, Global.APP_NAME, MessageBox.ERROR_MESSAGE);
}
}
});
////////////////////////////////////////////////////////
btnKick.addActionListener(
new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent evt) {
int iSelected = tblUser.getSelectedRow();
if (iSelected < 0) return;
int iResult =
MessageBox.showConfirmDialog(
pnlThread,
mdic.getString("ConfirmKick"),
Global.APP_NAME,
MessageBox.YES_NO_OPTION);
if (iResult == MessageBox.NO_OPTION) return;
try {
String strChannel = (String) tblUser.getRow(iSelected).elementAt(0);
DDTP request = new DDTP();
request.setRequestID(String.valueOf(System.currentTimeMillis()));
request.setString("strChannel", strChannel);
DDTP response = channel.sendRequest("ThreadProcessor", "kickUser", request);
} catch (Exception e) {
e.printStackTrace();
MessageBox.showMessageDialog(pnlThread, e, Global.APP_NAME, MessageBox.ERROR_MESSAGE);
}
}
});
////////////////////////////////////////////////////////
txtMessage.addActionListener(
new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent evt) {
btnSend.doClick();
}
});
////////////////////////////////////////////////////////
btnSend.addActionListener(
new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent evt) {
if (txtMessage.getText().length() == 0) return;
try {
DDTP request = new DDTP();
request.setString("strMessage", txtMessage.getText());
channel.sendRequest("ThreadProcessor", "sendMessage", request);
txtMessage.setText("");
} catch (Exception e) {
e.printStackTrace();
MessageBox.showMessageDialog(pnlThread, e, Global.APP_NAME, MessageBox.ERROR_MESSAGE);
}
}
});
////////////////////////////////////////////////////////
mnuClearAll.addActionListener(
new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
clearAll(txtBoard);
}
});
////////////////////////////////////////////////////////
mnuClearSelected.addActionListener(
new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
txtBoard.setEditable(true);
txtBoard.replaceSelection("");
txtBoard.setEditable(false);
}
});
////////////////////////////////////////////////////////
mnuSelectAll.addActionListener(
new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
txtBoard.requestFocus();
txtBoard.selectAll();
}
});
////////////////////////////////////////////////////////
txtBoard.addMouseListener(
new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getButton() == e.BUTTON3) pmn.show(txtBoard, e.getX(), e.getY());
}
});
////////////////////////////////////////////////////////
mnuSystem_Login.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
login();
}
});
////////////////////////////////////////////////////////
mnuSystem_ChangePassword.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
changePassword();
}
});
////////////////////////////////////////////////////////
mnuSystem_StopServer.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
stopServer();
}
});
////////////////////////////////////////////////////////
mnuSystem_EnableThreads.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
manageThreads();
}
});
////////////////////////////////////////////////////////
mnuHelp_About.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
WindowManager.centeredWindow(new DialogAbout(PanelThreadManager.this));
}
});
////////////////////////////////////////////////////////
chkVietnamese.addActionListener(
new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
switchKeyboard();
}
});
}
public String getAppVersion() {
return StringUtil.nvl(mstrAppVersion, "Unknown version");
}
public String getAppName() {
return StringUtil.nvl(mstrAppName, "Unknown application");
}
public String getThreadAppName() {
return StringUtil.nvl(mstrThreadAppName, "Unknown platform");
}
public void login() {
mbAutoLogIn = false;
while (!mbAutoLogIn) {
try {
// Confirm logout
if (isOpen()) {
if (MessageBox.showConfirmDialog(
this,
MonitorDictionary.getString("Confirm.Exit"),
Global.APP_NAME,
MessageBox.YES_NO_OPTION)
== MessageBox.NO_OPTION) return;
// Disconnect from server
disconnect();
}
// Login
DialogLogin dlgLogin = new DialogLogin(this);
WindowManager.centeredWindow(dlgLogin);
if (dlgLogin.miReturn == JOptionPane.OK_OPTION) {
// Update UI
SwingUtilities.updateComponentTreeUI(pnlUser);
SwingUtilities.updateComponentTreeUI(pnlThread);
// Request to connect
Socket sck = new Socket(dlgLogin.mstrHost, Integer.parseInt(dlgLogin.mstrPort));
sck.setSoLinger(true, 0);
// Start up a channel thread that reads messages from the server
channel =
new SocketTransmitter(sck) {
public void close() {
if (msckMain != null) {
super.close();
closeAll();
if (mbAutoLogIn) login();
}
}
};
channel.setUserName(dlgLogin.mstrUserName);
channel.setPackage("com.fss.thread.");
channel.start();
// Request to Server
DDTP request = new DDTP();
request.setRequestID(String.valueOf(System.currentTimeMillis()));
request.setString("UserName", dlgLogin.mstrUserName);
request.setString("Password", dlgLogin.mstrPassword);
// Response from Server
DDTP response = channel.sendRequest("ThreadProcessor", "login", request);
mstrThreadAppName = response.getString("strThreadAppName");
mstrThreadAppVersion = response.getString("strThreadAppVersion");
mstrAppName = response.getString("strAppName");
mstrAppVersion = response.getString("strAppVersion");
if (response != null) {
if (response.getString("PasswordExpired") != null) {
DialogChangePassword frm = new DialogChangePassword(this, channel);
WindowManager.centeredWindow(frm);
if (frm.miReturnValue != JOptionPane.OK_OPTION) throw new AppException("FSS-10003");
}
String strLog = StringUtil.nvl(response.getString("strLog"), "");
showResult(txtBoard, strLog);
Vector vtThread = response.getVector("vtThread");
updateTabBar(vtThread);
mstrChannel = response.getString("strChannel");
if (mstrChannel != null) removeUser(mstrChannel);
}
btnRefresh.doClick();
pnlThread.setVisible(true);
pnlUser.setVisible(true);
setResizeWeight(1);
setDividerLocation((int) (getSize().getHeight() - 160));
}
mbAutoLogIn = true;
updateLanguage();
} catch (Exception e) {
e.printStackTrace();
MessageBox.showMessageDialog(this, e, Global.APP_NAME, MessageBox.ERROR_MESSAGE);
// Disconnect from server
mstrChannel = null;
disconnect();
}
}
}
protected boolean hasNoRoleParsm(String roleName) {
String noRoleParam = noRoleParams.get(roleName);
return (noRoleParam != null && !StringUtil.isNullString(req.getParameter(noRoleParam)));
}