Update of /cvsroot/metamorphosis/ruper2/src/java/core/org/krysalis/ruper2/api/tool
In directory sc8-pr-cvs1:/tmp/cvs-serv30481/src/java/core/org/krysalis/ruper2/api/tool
Added Files:
ClasspathUpdater.java FileUpdater.java
Log Message:
Avoid clash with existing Ruper...
--- NEW FILE: ClasspathUpdater.java ---
/*
* Created on Aug 27, 2003
*/
package org.krysalis.ruper2.api.tool;
import java.util.ArrayList;
import java.util.Iterator;
import org.krysalis.ruper2.ResourceUpdater;
import org.krysalis.ruper2.RuperException;
import org.krysalis.ruper2.impl.ResourceUpdaterIdentifier;
import org.krysalis.version.util.classpath.PathPart;
import org.krysalis.version.util.classpath.PathSet;
/**
* @author arb_jack
*/
public class ClasspathUpdater extends FileUpdater {
/**
*
*/
public ClasspathUpdater(String identifier) throws RuperException {
this(new ResourceUpdaterIdentifier(identifier));
}
/**
*
*/
public ClasspathUpdater(ResourceUpdaterIdentifier identifier)
throws RuperException {
this(ResourceUpdater.getResourceUpdater(identifier, true));
}
/**
*
*/
public ClasspathUpdater(ResourceUpdater ruper) {
super(ruper);
}
public void updateClasspathFiles(final String classpathStr)
throws RuperException {
PathSet classpath = new PathSet(/* getIdentifier().getId() */
":TODO:", classpathStr);
updateClasspathFiles(classpath);
}
public void updateClasspathFiles(final PathSet classpath)
throws RuperException {
ArrayList files = new ArrayList();
for (Iterator i = classpath.iterator(); i.hasNext();) {
PathPart part = (PathPart) i.next();
files.add(part.getPart());
}
updateFiles(files);
}
}
--- NEW FILE: FileUpdater.java ---
/*
* Created on Aug 27, 2003
*/
package org.krysalis.ruper2.api.tool;
import java.io.File;
import java.util.Iterator;
import java.util.List;
import org.krysalis.ruper2.ResourceUpdater;
import org.krysalis.ruper2.RuperException;
import org.krysalis.ruper2.api.FileAPI;
import org.krysalis.ruper2.impl.ResourceUpdaterIdentifier;
import org.krysalis.ruper2.log.Logger;
import org.krysalis.ruper2.query.ResourceQuery;
import org.krysalis.ruper2.query.ResourceRequest;
import org.krysalis.ruper2.query.ResourceResult;
import org.krysalis.ruper2.query.ResourceResultHelper;
import org.krysalis.ruper2.query.ResourceSpecifierRequest;
import org.krysalis.ruper2.repository.DefaultRepository;
import org.krysalis.ruper2.repository.Repository;
import org.krysalis.ruper2.repository.RepositoryAttribute;
import org.krysalis.ruper2.repository.RepositoryConstants;
import org.krysalis.ruper2.repository.RepositorySet;
import org.krysalis.ruper2.repository.RepositorySetIdentifier;
import org.krysalis.ruper2.repository.RepositorySetSortContext;
import org.krysalis.ruper2.repository.select.ActiveRepositorySelector;
import org.krysalis.ruper2.repository.select.LocalRepositorySelector;
import org.krysalis.ruper2.repository.select.RemoteRepositorySelector;
import org.krysalis.ruper2.util.RuperConstants;
import org.krysalis.ruper2.util.text.MessageConstants;
import org.krysalis.ruper2.util.text.Messages;
/**
* @author arb_jack
*/
public class FileUpdater /* implements Referenceable */ {
private ResourceUpdater m_ruper = null;
private FileAPI m_api = null;
/**
*
*/
public FileUpdater() throws RuperException {
this(
new FileAPI(),
new ResourceUpdaterIdentifier(RuperConstants.DEFAULT));
}
/**
*
*/
public FileUpdater(String identifier) throws RuperException {
this(new FileAPI(), new ResourceUpdaterIdentifier(identifier));
}
/**
*
*/
public FileUpdater(String ruperId, String reposId) throws RuperException {
this(
new FileAPI(),
new ResourceUpdaterIdentifier(ruperId),
new RepositorySetIdentifier(reposId));
}
/**
*
*/
public FileUpdater(FileAPI api, String identifier) throws RuperException {
this(api, new ResourceUpdaterIdentifier(identifier));
}
/**
*
*/
public FileUpdater(FileAPI api, ResourceUpdaterIdentifier identifier)
throws RuperException {
this(api, ResourceUpdater.getResourceUpdater(identifier, true));
}
/**
*
*/
public FileUpdater(
FileAPI api,
ResourceUpdaterIdentifier ruperId,
RepositorySetIdentifier reposId)
throws RuperException {
this(
api,
ResourceUpdater.getResourceUpdater(ruperId, true),
RepositorySet.getRepositorySet(reposId, true));
}
/**
*
*/
public FileUpdater(FileAPI api, ResourceUpdater ruper) {
m_ruper = ruper;
m_api = api;
}
/**
*
*/
public FileUpdater(
FileAPI api,
ResourceUpdater ruper,
RepositorySet repos) {
m_ruper = ruper;
m_api = api;
}
/**
*
*/
public FileUpdater(ResourceUpdater ruper) {
m_ruper = ruper;
m_api = new FileAPI();
}
public void updateFiles(List files) throws RuperException {
for (Iterator i = files.iterator(); i.hasNext();) {
updateFile((File) i.next());
}
}
public void updateFiles(List files, Repository target)
throws RuperException {
for (Iterator i = files.iterator(); i.hasNext();) {
updateFile((File) i.next(), target);
}
}
public void updateFiles(File file) throws RuperException {
//All files in a folder...
if (!file.isDirectory()) {
updateFile(file);
}
else {
// We have a folder of files...
File folder = file;
File[] files = folder.listFiles();
DefaultRepository target =
new DefaultRepository(folder.getAbsolutePath(), folder, false);
// set the local repository attribute to true
target.setRepositoryAttribute(
new RepositoryAttribute(RepositoryConstants.REMOTE),
RepositoryConstants.FALSE);
for (int i = 0; i < files.length; ++i) {
File childFile = files[i];
updateFile(childFile, target);
}
}
}
public void updateFile(File file) throws RuperException {
File parentFolder =
m_api.resolveFile(m_api.resolveFile(file).getParent());
//
// A flat repository to put things
//
Repository target =
new DefaultRepository(
parentFolder.getAbsolutePath(),
parentFolder,
false);
updateFile(file, target);
}
public void updateFile(File file, Repository target)
throws RuperException {
//
// Generate a request from the file
//
ResourceRequest request =
new ResourceSpecifierRequest(
m_api.getResourceSpecifierForFile(file));
//
// Extract the query for this request
//
ResourceQuery resourceQuery = request.getQuery();
Logger.getLog().debug(
Messages.getString(MessageConstants.RESOURCE_REQUEST, request));
//
// Perform the query on the remote repository
//
ResourceResult resourceResult =
queryRepository(RepositoryConstants.REMOTE, resourceQuery);
//
// Now perform same query over local (target) repo
//
RepositorySet localRepositorySet =
RepositorySet.getRepositorySet(RepositoryConstants.LOCAL, true);
localRepositorySet.addRepository(target);
resourceQuery.setRepositorySet(localRepositorySet);
ResourceResult targetResult =
queryRepository(RepositoryConstants.LOCAL, resourceQuery);
//
// Assuming we found something in the main search repositories...
//
if (!ResourceResultHelper.noResult(resourceResult)) {
// Compare Results Set using the OrderBy Comparator
if (ResourceResultHelper
.compareTo(
resourceResult,
targetResult,
resourceQuery.getOrderBy())
> 0) {
List resources =
ResourceResultHelper.getResourceList(resourceResult);
Logger.getLog().verbose(
Messages.getString(
MessageConstants.UPDATE_FOUND,
resources));
//
// Copy the resource to the repository
//
m_ruper.copyTo(resources, target);
}
else
Logger.getLog().verbose(
Messages.getString(
MessageConstants.NO_UPDATE_FOUND,
resourceQuery));
}
else
Logger.getLog().verbose(
Messages.getString(
MessageConstants.NO_RESOURCES_FOUND,
resourceQuery));
}
private ResourceResult queryRepository(
String repositoryConstant,
ResourceQuery resourceQuery)
throws RuperException {
//
// get the sortcontext for remote repository
//
RepositorySetSortContext repositorySortContext =
RepositorySetSortContext.getRepositorySetSortContext(
repositoryConstant);
if (repositorySortContext == null) {
repositorySortContext =
RepositorySetSortContext.createRepositorySetSortContext(
repositoryConstant);
// add the remote selector and the active repository selector
repositorySortContext.addRepositorySelector(
new ActiveRepositorySelector());
if (repositoryConstant.equals(RepositoryConstants.REMOTE))
repositorySortContext.addRepositorySelector(
new RemoteRepositorySelector());
else if (repositoryConstant.equals(RepositoryConstants.LOCAL))
repositorySortContext.addRepositorySelector(
new LocalRepositorySelector());
}
resourceQuery.setRepositorySetSortContext(repositorySortContext);
return m_ruper.query(resourceQuery);
}
public ResourceResult determineFilesUpdates(String fileName)
throws RuperException {
return determineFilesUpdates(new File(fileName));
}
public ResourceResult determineFilesUpdates(File file)
throws RuperException {
ResourceResult result = null;
if (!file.isDirectory()) {
result = determineFileUpdates(file);
}
else {
// We have a folder of files...
File folder = file;
File[] files = folder.listFiles();
for (int i = 0; i < files.length; ++i) {
File childFile = files[i];
//:TODO: add ResultHelper.merge
result = determineFileUpdates(childFile);
}
}
return result;
}
public ResourceResult determineFileUpdates(String fileName)
throws RuperException {
return determineFileUpdates(new File(fileName));
}
public ResourceResult determineFileUpdates(File file)
throws RuperException {
ResourceRequest request =
new ResourceSpecifierRequest(
m_api.getResourceSpecifierForFile(file));
if (!file.isDirectory()) {
updateFile(file);
}
else {
// We have a folder of files...
File folder = file;
File[] files = folder.listFiles();
DefaultRepository target =
new DefaultRepository(folder.getAbsolutePath(), folder, false);
// set the local repository attribute to true
target.setRepositoryAttribute(
new RepositoryAttribute(RepositoryConstants.REMOTE),
RepositoryConstants.FALSE);
for (int i = 0; i < files.length; ++i) {
File childFile = files[i];
updateFile(childFile, target);
}
}
return m_ruper.performRequest(request);
}
public static void main(String args[]) throws Exception {
Logger.testInit();
String file = "lib/test.jar";
if (args.length > 0)
file = args[0];
FileUpdater fu = new FileUpdater(new FileAPI(), "test");
fu.updateFile(new File(file));
}
}
-------------------------------------------------------
This sf.net email is sponsored by:ThinkGeek
Welcome to geek heaven.
http://thinkgeek.com/sf
lmpx.com only provides a reader for public news (NNTP) servers. It is not
affiliated with the servers or forums shown here and is not responsible for
the content of articles, which is written by their respective authors.