/** Create LockssKeystores from config subtree below {@link #PARAM_KEYSTORE} */
void configureKeyStores(Configuration config) {
Configuration allKs = config.getConfigTree(PARAM_KEYSTORE);
for (Iterator iter = allKs.nodeIterator(); iter.hasNext(); ) {
String id = (String) iter.next();
Configuration oneKs = allKs.getConfigTree(id);
try {
LockssKeyStore lk = createLockssKeyStore(oneKs);
String name = lk.getName();
if (name == null) {
log.error("KeyStore definition missing name: " + oneKs);
continue;
}
LockssKeyStore old = keystoreMap.get(name);
if (old != null && !lk.equals(old)) {
log.warning(
"Keystore "
+ name
+ " redefined. "
+ "New definition may not take effect until daemon restart");
}
log.debug("Adding keystore " + name);
keystoreMap.put(name, lk);
} catch (Exception e) {
log.error("Couldn't create keystore: " + oneKs, e);
}
}
}
public Map<String, PlatformUtil.DF> getRepositoryMap() {
Map<String, PlatformUtil.DF> repoMap = new LinkedMap();
for (String repo : getRepositoryList()) {
repoMap.put(repo, getRepositoryDF(repo));
}
return repoMap;
}
/**
* Return the request parameters as a Map<String,String>. Only the first value of multivalued
* parameters is included.
*/
Map<String, String> getParamsAsMap() {
Map<String, String> map = new HashMap<String, String>();
for (Enumeration en = req.getParameterNames(); en.hasMoreElements(); ) {
String name = (String) en.nextElement();
map.put(name, req.getParameter(name));
}
return map;
}
// hack only local
public synchronized LockssRepositoryImpl getRepositoryFromPath(String path) {
LockssRepositoryImpl repo = (LockssRepositoryImpl) localRepos.get(path);
if (repo == null) {
repo = new LockssRepositoryImpl(path);
repo.initService(getDaemon());
repo.startService();
localRepos.put(path, repo);
}
return repo;
}
static LocalRepository getLocalRepository(String repoRoot) {
synchronized (localRepositories) {
LocalRepository localRepo = (LocalRepository) localRepositories.get(repoRoot);
if (localRepo == null) {
logger.debug2("Creating LocalRepository(" + repoRoot + ")");
localRepo = new LocalRepository(repoRoot);
localRepositories.put(repoRoot, localRepo);
}
return localRepo;
}
}
void loadKeyStores() {
List<LockssKeyStore> lst = new ArrayList<LockssKeyStore>(keystoreMap.values());
for (LockssKeyStore lk : lst) {
try {
lk.load();
} catch (Exception e) {
log.error("Can't load keystore " + lk.getName(), e);
keystoreMap.remove(lk.getName());
}
}
}
public String findLeastFullRepository(Map<String, PlatformUtil.DF> repoMap) {
String mostFree = null;
for (String repo : repoMap.keySet()) {
PlatformUtil.DF df = repoMap.get(repo);
if (df != null) {
if (mostFree == null || (repoMap.get(mostFree)).getAvail() < df.getAvail()) {
mostFree = repo;
}
}
}
return mostFree;
}
/*
* When testing no-pdf-check basic XML parsing, you will get partial MD records
* depending on whether the info comes from dataset.xml or from main.xml
*/
private void validateDatasetMetadataRecord(ArticleMetadata am) {
log.debug3("valideDatasetMetadatRecord");
String doi_val = am.get(MetadataField.FIELD_DOI);
assertEquals(common_issn, am.get(MetadataField.FIELD_ISSN));
log.debug3("doi val is: " + doi_val);
// The dataset doesn't set this value, it'll fail over the main.xml value
if (doi_val.equals("10.1016/S0140-1111(14)61865-1")) {
assertEquals(null, am.get(MetadataField.FIELD_DATE));
} else {
assertEquals(dateMap.get(doi_val), am.get(MetadataField.FIELD_DATE));
}
assertEquals(pubTitleMap.get(doi_val), am.get(MetadataField.FIELD_PUBLICATION_TITLE));
}
static String canonRoot(String root) {
synchronized (canonicalRoots) {
String canon = (String) canonicalRoots.get(root);
if (canon == null) {
try {
canon = new File(root).getCanonicalPath();
canonicalRoots.put(root, canon);
} catch (IOException e) {
logger.warning("Can't canonicalize: " + root, e);
return root;
}
}
return canon;
}
}
/*
* You will have to tell it the DOI and the schema because those normally come from dataset
*/
private void validateSingleMainMetadataRecord(ArticleMetadata am, String doi_val, String schema) {
log.debug3("valideSingleMainMetadatRecord");
if ("simple-article".equals(schema)) {
assertEquals(common_simple_article_title, am.get(MetadataField.FIELD_ARTICLE_TITLE));
} else {
assertEquals(common_article_title, am.get(MetadataField.FIELD_ARTICLE_TITLE));
}
log.debug3("doi val is: " + doi_val);
assertEquals(authorMap.get(doi_val), am.getList(MetadataField.FIELD_AUTHOR));
assertEquals(volMap.get(doi_val), am.get(MetadataField.FIELD_VOLUME));
assertEquals(issueMap.get(doi_val), am.get(MetadataField.FIELD_ISSUE));
assertEquals("Comment", am.getRaw(ElsevierMainDTD5XmlSchemaHelper.common_dochead));
assertEquals(doi_val, am.getRaw(ElsevierMainDTD5XmlSchemaHelper.common_doi));
assertEquals("2014", am.getRaw(ElsevierMainDTD5XmlSchemaHelper.common_copyright));
}
/**
* Finds the directory for this AU. If none found in the map, designates a new dir for it.
*
* @param auid AU id representing the au
* @param repoRoot path to the root of the repository
* @return the dir String
*/
static String getAuDir(String auid, String repoRoot, boolean create) {
String repoCachePath = extendCacheLocation(repoRoot);
LocalRepository localRepo = getLocalRepository(repoRoot);
synchronized (localRepo) {
Map aumap = localRepo.getAuMap();
String auPathSlash = (String) aumap.get(auid);
if (auPathSlash != null) {
return auPathSlash;
}
if (!create) {
return null;
}
logger.debug3("Creating new au directory for '" + auid + "'.");
String auDir = localRepo.getPrevAuDir();
for (int cnt = RepositoryManager.getMaxUnusedDirSearch(); cnt > 0; cnt--) {
// loop through looking for an available dir
auDir = getNextDirName(auDir);
File testDir = new File(repoCachePath, auDir);
if (logger.isDebug3()) logger.debug3("Probe for unused: " + testDir);
if (!testDir.exists()) {
if (RepositoryManager.isStatefulUnusedDirSearch()) {
localRepo.setPrevAuDir(auDir);
}
String auPath = testDir.toString();
logger.debug3("New au directory: " + auPath);
auPathSlash = auPath + File.separator;
// write the new au property file to the new dir
// XXX this data should be backed up elsewhere to avoid single-point
// corruption
Properties idProps = new Properties();
idProps.setProperty(AU_ID_PROP, auid);
saveAuIdProperties(auPath, idProps);
aumap.put(auid, auPathSlash);
return auPathSlash;
} else {
if (logger.isDebug3()) {
logger.debug3("Existing directory found at '" + auDir + "'. Checking next...");
}
}
}
}
throw new RuntimeException(
"Can't find unused repository dir after "
+ RepositoryManager.getMaxUnusedDirSearch()
+ " tries in "
+ repoCachePath);
}
/**
* Return the auid -> au-subdir-path mapping. Enumerating the directories if necessary to
* initialize the map
*/
Map getAuMap() {
if (auMap == null) {
logger.debug3("Loading name map for '" + repoCacheFile + "'.");
auMap = new HashMap();
if (!repoCacheFile.exists()) {
logger.debug3("Creating cache dir:" + repoCacheFile + "'.");
if (!repoCacheFile.mkdirs()) {
logger.critical("Couldn't create directory, check owner/permissions: " + repoCacheFile);
// return empty map
return auMap;
}
} else {
// read each dir's property file and store mapping auid -> dir
File[] auDirs = repoCacheFile.listFiles();
for (int ii = 0; ii < auDirs.length; ii++) {
String dirName = auDirs[ii].getName();
// if (dirName.compareTo(lastPluginDir) == 1) {
// // adjust the 'lastPluginDir' upwards if necessary
// lastPluginDir = dirName;
// }
String path = auDirs[ii].getAbsolutePath();
Properties idProps = getAuIdProperties(path);
if (idProps != null) {
String auid = idProps.getProperty(AU_ID_PROP);
StringBuilder sb = new StringBuilder(path.length() + File.separator.length());
sb.append(path);
sb.append(File.separator);
auMap.put(auid, sb.toString());
logger.debug3("Mapping to: " + auMap.get(auid) + ": " + auid);
} else {
logger.debug3("Not mapping " + path + ", no auid file.");
}
}
}
}
return auMap;
}
/*
* When testing a complete extraction out of the tarset, the MD record will be completely filled in
* and pdf-existence will get established
*/
private void validateCompleteMetadataRecord(ArticleMetadata am) {
log.debug3("valideCompleteMetadatRecord");
String doi_val = am.get(MetadataField.FIELD_DOI);
/* make sure we can pick up both types of xml article data */
log.debug3("doi val is: " + doi_val);
if ("JA 5.2.0 SIMPLE-ARTICLE"
.equals(am.getRaw(ElsevierDatasetXmlSchemaHelper.dataset_dtd_metadata))) {
log.debug3("simple-article");
assertEquals(common_simple_article_title, am.get(MetadataField.FIELD_ARTICLE_TITLE));
} else {
assertEquals(common_article_title, am.get(MetadataField.FIELD_ARTICLE_TITLE));
}
assertEquals(common_issn, am.get(MetadataField.FIELD_ISSN));
assertEquals(authorMap.get(doi_val), am.getList(MetadataField.FIELD_AUTHOR));
assertEquals(dateMap.get(doi_val), am.get(MetadataField.FIELD_DATE));
assertEquals(accessUrlMap.get(doi_val), am.get(MetadataField.FIELD_ACCESS_URL));
assertEquals(volMap.get(doi_val), am.get(MetadataField.FIELD_VOLUME));
assertEquals(issueMap.get(doi_val), am.get(MetadataField.FIELD_ISSUE));
assertEquals(pubTitleMap.get(doi_val), am.get(MetadataField.FIELD_PUBLICATION_TITLE));
assertEquals("Elsevier", am.get(MetadataField.FIELD_PROVIDER));
assertEquals("Elsevier", am.get(MetadataField.FIELD_PUBLISHER));
log.debug3(am.ppString(2));
}
/**
* Return the named LockssKeyStore
*
* @param name the keystore name
* @param criticalServiceName if non-null, this is a criticial keystore whose unavailability
* should cause the daemon to exit (if org.lockss.keyMgr.exitIfMissingKeystore is true)
*/
public LockssKeyStore getLockssKeyStore(String name, String criticalServiceName) {
LockssKeyStore res = keystoreMap.get(name);
checkFact(res, name, criticalServiceName, null);
return res;
}
/*
* The supporting methods
*/
private void setUpExpectedTarContent() {
/* maps the DOIs in the metadata to the expected values */
log.debug3("setUpExpectedTarContent");
pubTitleMap = new HashMap<String, String>();
{
pubTitleMap.put("10.1016/j.jidx.2014.07.028", "International Journal of XXX");
pubTitleMap.put("10.1016/j.jidx2.2014.05.013", "Revista");
pubTitleMap.put("10.1016/S1473-1111(14)70840-0", "The Journal");
pubTitleMap.put("10.1016/S0140-1111(14)61865-1", "The Other Journal");
pubTitleMap.put("10.1016/j.foo.2014.08.001", "Foo");
pubTitleMap.put("10.1016/j.foo.2014.08.123", "Foo");
}
;
dateMap = new HashMap<String, String>();
{
dateMap.put("10.1016/j.jidx.2014.07.028", "2014-07-30");
dateMap.put("10.1016/j.jidx2.2014.05.013", "2014-07-09");
dateMap.put("10.1016/S1473-1111(14)70840-0", "2014-09-01");
dateMap.put("10.1016/S0140-1111(14)61865-1", "2014"); // will get from main.xml as backup
dateMap.put("10.1016/j.foo.2014.08.001", "2014-08-20");
dateMap.put("10.1016/j.foo.2014.08.123", "2014-08-20");
}
;
accessUrlMap = new HashMap<String, String>();
{
accessUrlMap.put(
"10.1016/j.jidx.2014.07.028",
TAR_A_BASE + SUBDIR + "01420615/v64sC/S0142061514004608/main.pdf");
accessUrlMap.put(
"10.1016/j.jidx2.2014.05.013",
TAR_A_BASE + SUBDIR + "00349356/v61i9/S0034935614001819/main.pdf");
accessUrlMap.put(
"10.1016/S1473-1111(14)70840-0",
TAR_A_BASE + SUBDIR + "14733099/v14i10/S1473309914708400/main.pdf");
accessUrlMap.put(
"10.1016/S0140-1111(14)61865-1",
TAR_B_BASE + SUBDIR + "01406736/v384sS1/S0140673614618651/main.pdf");
accessUrlMap.put(
"10.1016/j.foo.2014.08.001",
TAR_B_BASE + SUBDIR + "00191035/v242sC/S0019103514004151/main.pdf");
accessUrlMap.put(
"10.1016/j.foo.2014.08.123",
TAR_B_BASE + SUBDIR + "00191035/v242sC/S0019103514003856/main.pdf");
}
;
ArrayList<String> goodAuthors = new ArrayList<String>();
{
goodAuthors.add("Writer, Bob");
goodAuthors.add("Q. Text, Samantha");
}
ArrayList<String> simpleAuthors = new ArrayList<String>();
{
simpleAuthors.add("Simple, Josh");
}
ArrayList<String> extendedAuthors = new ArrayList<String>();
{
extendedAuthors.add("Writer, Bob");
extendedAuthors.add("Q. Text, Samantha");
extendedAuthors.add("The COLLABORATIVE Investigators");
}
authorMap = new HashMap<String, List<String>>();
{
authorMap.put("10.1016/j.jidx.2014.07.028", goodAuthors);
authorMap.put("10.1016/j.jidx2.2014.05.013", goodAuthors);
authorMap.put("10.1016/S1473-1111(14)70840-0", extendedAuthors);
authorMap.put("10.1016/S0140-1111(14)61865-1", simpleAuthors);
authorMap.put("10.1016/j.foo.2014.08.001", goodAuthors);
authorMap.put("10.1016/j.foo.2014.08.123", goodAuthors);
}
;
volMap = new HashMap<String, String>();
{
volMap.put("10.1016/j.jidx.2014.07.028", "64");
volMap.put("10.1016/j.jidx2.2014.05.013", "61");
volMap.put("10.1016/S1473-1111(14)70840-0", "14");
volMap.put("10.1016/S0140-1111(14)61865-1", "384");
volMap.put("10.1016/j.foo.2014.08.001", "242");
volMap.put("10.1016/j.foo.2014.08.123", "242");
}
;
issueMap = new HashMap<String, String>();
{
issueMap.put("10.1016/j.jidx.2014.07.028", "C");
issueMap.put("10.1016/j.jidx2.2014.05.013", "9");
issueMap.put("10.1016/S1473-1111(14)70840-0", "10");
issueMap.put("10.1016/S0140-1111(14)61865-1", "S1");
issueMap.put("10.1016/j.foo.2014.08.001", "C");
issueMap.put("10.1016/j.foo.2014.08.123", "C");
}
;
}
protected boolean hasNoRoleParsm(String roleName) {
String noRoleParam = noRoleParams.get(roleName);
return (noRoleParam != null && !StringUtil.isNullString(req.getParameter(noRoleParam)));
}
static {
noRoleParams.put(ROLE_USER_ADMIN, "noadmin");
noRoleParams.put(ROLE_CONTENT_ADMIN, "nocontent");
noRoleParams.put(ROLE_AU_ADMIN, "noau");
noRoleParams.put(ROLE_DEBUG, "nodebug");
}
public synchronized void setRepositoryForPath(String path, LockssRepositoryImpl repo) {
localRepos.put(path, repo);
}