/*
* 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 com.sun.jini.tool.envcheck.plugins;
import com.sun.jini.start.NonActivatableServiceDescriptor;
import com.sun.jini.start.SharedActivatableServiceDescriptor;
import com.sun.jini.start.SharedActivationGroupDescriptor;
import com.sun.jini.start.ServiceDescriptor;
import com.sun.jini.tool.envcheck.AbstractPlugin;
import com.sun.jini.tool.envcheck.EnvCheck;
import com.sun.jini.tool.envcheck.Plugin;
import com.sun.jini.tool.envcheck.Reporter;
import com.sun.jini.tool.envcheck.Reporter.Message;
import com.sun.jini.tool.envcheck.SubVMTask;
import com.sun.jini.tool.envcheck.Util;
import java.io.File;
import java.io.IOException;
import java.net.InetAddress;
import java.net.URL;
import java.net.URLClassLoader;
import java.rmi.activation.ActivationException;
import java.rmi.activation.ActivationGroup;
import java.rmi.RMISecurityManager;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Properties;
import java.util.ResourceBundle;
import java.util.Set;
import net.jini.config.Configuration;
import net.jini.config.ConfigurationException;
import net.jini.config.ConfigurationFile;
import net.jini.config.ConfigurationProvider;
import net.jini.config.NoSuchEntryException;
/**
* Check that the persistence directory supplied by any
* <code>SharedActivatableServiceDescriptor</code>s are either non-existant or
* empty. Check is performed in a subtask VM started identically to how the
* activation system would have started it. The first entry in the service
* configuration named <code>persistenceDirectory</code> is checked. Doesn't
* work correctly if multiple services share a configuration. Don't know how to
* handle this.
*/
public class CheckPersistence extends AbstractPlugin {
EnvCheck envCheck;
/**
* Check the persistence directory for every
* <code>SharedActivatableServiceDescriptor</code> in the starter
* configuration.
*
* @param envCheck the plugin container
*/
public void run(EnvCheck envCheck) {
this.envCheck = envCheck;
ServiceDescriptor[] d = envCheck.getDescriptors();
for (int i = 0; i < d.length; i++) {
if (d[i] instanceof SharedActivatableServiceDescriptor) {
SharedActivatableServiceDescriptor sd =
(SharedActivatableServiceDescriptor) d[i];
checkDirectory(sd);
}
}
}
/**
* Launch a subtask for the given descriptor to obtain all the
* <code>persistenceDirectory</code> entries. Check each
* entry found for validity.
*
* @param sd the descriptor to check, which must be a
* <code>SharedActivatableServiceDescriptor</code
*/
private void checkDirectory(SharedActivatableServiceDescriptor d) {
SharedActivationGroupDescriptor gd = envCheck.getGroupDescriptor();
String source = getString("descfor", d.getImplClassName());
Object o = envCheck.launch(d, gd, taskName("GetEntriesTask"));
if (o instanceof String[]) {
checkEntries((String[]) o, d, source);
} else if (o instanceof String) {
Message message = new Message(Reporter.WARNING,
(String) o,
getString("dirExp"));
Reporter.print(message, source);
} else {
handleUnexpectedSubtaskReturn(o, source);
}
}
/**
* Check <code>entries</code> for validity. <code>entries</code>
* contains a collection of pairs, the first being the fully
* qualified name of the <code>persistenceDirectory</code> entry,
* and the second being its value.
*
* @param entries the array of entry/value pairs
* @param d the descriptor
* @param source the source descriptive text
*/
private void checkEntries(String[] entries,
SharedActivatableServiceDescriptor d,
String source)
{
if (entries.length == 0) {
Message message = new Message(Reporter.WARNING,
getString("noentry"),
getString("dirExp"));
Reporter.print(message, source);
}
for (int i = 0; i < entries.length; i += 2) {
String name = entries[i];
String dir = entries[i + 1];
String loopSource = source + ": " + name + "=" + dir;
Object lobj = checkDir(dir, d);
Message message;
if (lobj == null) {
message = new Message(Reporter.INFO,
getString("dirOK"),
getString("dirExp"));
Reporter.print(message, loopSource);
} else if (lobj instanceof String) {
message = new Message(Reporter.ERROR,
(String) lobj,
getString("dirExp"));
Reporter.print(message, loopSource);
} else {
handleUnexpectedSubtaskReturn(lobj, loopSource);
}
}
}
/**
* Perform a check on the given persistence directory.
*
* @param dir the name of the directory to check
* @param d the service descriptor
* @return <code>null</code> if the specified directory is empty
* or non-existant (i.e. OK). Otherwise returns an error message
* or <code>Throwable</code> returned by the subtask.
*/
private Object checkDir(String dir, SharedActivatableServiceDescriptor d) {
if (dir == null) {
return getString("nulldir");
}
String taskName = taskName("CheckDirTask");
String[] args = new String[]{dir};
SharedActivationGroupDescriptor g = envCheck.getGroupDescriptor();
return envCheck.launch(d, g, taskName, args);
}
/**
* Perform directory check with an active security policy in place.
*/
public static class CheckDirTask implements SubVMTask {
private ResourceBundle bundle =
Util.getResourceBundle(CheckPersistence.class);
public Object run(String[] args) {
System.setSecurityManager(new RMISecurityManager());
String dir = args[0];
File dirFile = new File(dir);
if (!dirFile.exists()) {
return null; // the OK value
}
if (!dirFile.isDirectory()) {
return Util.getString("notadir", bundle, dir);
}
File[] contents = dirFile.listFiles();
if (contents == null) { // should never happen
return Util.getString("emptylist", bundle, dir);
}
if (contents.length > 0) {
return Util.getString("dirnotempty", bundle, dir);
}
return null; // directory exists but is empty
}
}
/**
* The subtask which obtains the list of persistence directory entries. The
* arg list is cleaned up, the configuration in obtained, and a String array
* of pairs of all entries named <code>persistenceDirectory</code> and
* their associated value is returned.
*/
public static class GetEntriesTask implements SubVMTask {
private ResourceBundle bundle =
Util.getResourceBundle(CheckPersistence.class);
public Object run(String[] args) {
try {
Configuration config =
ConfigurationProvider.getInstance(args);
return getEntries(config);
} catch (ConfigurationException e) {
return Util.getString("configproblem", bundle, e.getMessage());
} catch (Exception e) {
return e;
}
}
/**
* Obtain all of the <code>persistenceDirectory</code> entries in the
* configuration and return them as pairs in a <code>String</code>
* array.
*
* @param conf the configuration to examine
* @return the array of entry/value pairs
*/
private Object getEntries(Configuration conf) {
ConfigurationFile cf = (ConfigurationFile) conf;
ArrayList list = new ArrayList();
Set names = cf.getEntryNames();
Iterator it = names.iterator();
String s = "";
while (it.hasNext()) {
String name = (String) it.next();
s += name + "\n";
int lastDot = name.lastIndexOf(".persistenceDirectory");
if (lastDot > 0) {
String component = name.substring(0, lastDot);
try {
String dir =
(String) conf.getEntry(component,
"persistenceDirectory",
String.class,
null);
list.add(name);
list.add(dir);
} catch (ConfigurationException e) {
return e;
}
}
}
return list.toArray(new String[list.size()]);
}
}
}