Update of
/cvsroot/metamorphosis/ruper2/src/java/core/org/krysalis/ruper2/repository
In directory
sc8-pr-cvs1:/tmp/cvs-serv30481/src/java/core/org/krysalis/ruper2/repository
Added Files:
RepositoryException.java MockRepository.java
RepositorySetSortContext.java RepositoryCapability.java
RepositoryIdentifier.java RepositoryAttribute.java
RepositorySet.java RepositoryManager.java
RepositorySetSortContextIdentifier.java
RepositorySorterConfig.java DefaultRepository.java
AbstractHierarchicalRepository.java RepositoryWrapper.java
RepositoryConstants.java AbstractRepository.java
RepositorySetIdentifier.java Repository.java
RepositoryAttributeMap.java RepositoryCapabilitySet.java
Log Message:
Avoid clash with existing Ruper...
--- NEW FILE: RepositoryException.java ---
/*
* Created on Sep 4, 2003
*/
package org.krysalis.ruper2.repository;
import org.krysalis.ruper2.RuperException;
/**
* @author arb_jack
*/
public class RepositoryException extends RuperException {
private Repository m_repository = null;
public RepositoryException(Repository repo, String message) {
super(message);
m_repository = repo;
}
public RepositoryException(Repository repo, String message, Throwable
t) {
super(message, t);
m_repository = repo;
}
}
--- NEW FILE: MockRepository.java ---
/*
* Created on Aug 27, 2003
*/
package org.krysalis.ruper2.repository;
import java.util.ArrayList;
import java.util.List;
import org.krysalis.ruper2.impl.ResourceUpdaterContext;
import org.krysalis.ruper2.protocols.VirtualResourceLocator;
import org.krysalis.ruper2.resource.Resource;
import org.krysalis.ruper2.resource.ResourceGroup;
import org.krysalis.ruper2.util.Flag;
import org.krysalis.ruper2.util.select.SelectionHelper;
import org.krysalis.ruper2.util.select.Selector;
/**
* @author arb_jack
*/
public class MockRepository extends AbstractHierarchicalRepository {
private final static List EMPTY_LIST = new ArrayList();
private boolean m_hierarchical = true;
MockRepository(String id) {
super(id, new
VirtualResourceLocator("http://mockrepo.org/stuff";));
classInit(m_hierarchical);
}
private void classInit(final boolean hierarchical) {
m_hierarchical = hierarchical;
setRepositoryAttribute(
RepositoryAttribute.HIERARCHICAL,
(hierarchical ? Flag.TRUE : Flag.FALSE));
addCapability(RepositoryCapability.PUBLISHABLE);
addCapability(RepositoryCapability.LISTABLE);
// make the repository active
setRepositoryAttribute(
new RepositoryAttribute(RepositoryConstants.ACTIVE),
RepositoryConstants.TRUE);
}
public List listGroups(ResourceUpdaterContext context, Selector
selector)
throws Exception {
List groups = new ArrayList();
// :TODO: Populate with some test groups...
groups.add(ResourceGroup.getTestGroup("test1"));
groups.add(ResourceGroup.getTestGroup("test2"));
groups.add(ResourceGroup.getTestGroup("test3"));
return groups;
}
public List listResources(
final ResourceUpdaterContext context,
final ResourceGroup group,
final Selector selector)
throws Exception {
List results = null;
VirtualResourceLocator container = folderForGroup(group);
List resourceList =
Resource.getTestResourceList(group.getGroup(),10);
results = SelectionHelper.select(resourceList, selector);
return results;
}
public Resource publishResource(
ResourceUpdaterContext context,
Resource resource)
throws Exception {
Resource publishedResource = new Resource(resource);
publishedResource.setLocation(
new VirtualResourceLocator(
folderForGroup(resource.getGroup()),
resource.getFilename()));
return publishedResource;
}
public static Repository getMockRepository() {
return new MockRepository("mockrepo");
}
}
--- NEW FILE: RepositorySetSortContext.java ---
/*
* Created on Sep 16, 2003
*/
package org.krysalis.ruper2.repository;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import org.krysalis.ruper2.impl.ReferenceManager;
import org.krysalis.ruper2.log.Logger;
import org.krysalis.ruper2.util.RuperConstants;
import org.krysalis.ruper2.util.identity.GenericIdentifier;
import org.krysalis.ruper2.util.reference.NoSuchReferenceException;
import org.krysalis.ruper2.util.reference.Referenceable;
import org.krysalis.ruper2.util.select.Selector;
/**
* @author anou_mana
*/
public class RepositorySetSortContext implements Referenceable {
private RepositorySetSortContextIdentifier m_identifier;
//handlers who can sort the repository list
private List m_repositoryComparators;
private List m_repositorySelectors;
/**
*
*/
public RepositorySetSortContext(String identifier) {
super();
m_identifier = new
RepositorySetSortContextIdentifier(identifier);
}
/**
* @return
*/
public List getRepositoryComparators() {
return m_repositoryComparators;
}
/**
* @return
*/
public List getRepositorySelectors() {
return m_repositorySelectors;
}
/**
* @param list
*/
public void setRepositoryComparators(List list) {
m_repositoryComparators = list;
}
/**
* @param list
*/
public void setRepositorySelectors(List list) {
m_repositorySelectors = list;
}
/*
* Add and remove the selectors
*/
public void addRepositorySelector(Selector selector) {
if (this.m_repositorySelectors == null)
this.m_repositorySelectors = new ArrayList();
this.m_repositorySelectors.add(selector);
}
public void removeRepositorySelector(Selector selector) {
if (this.m_repositorySelectors != null)
this.m_repositorySelectors.remove(selector);
}
/*
* Add and remove the comparators
*/
public void addRepositoryComparator(Comparator comparator) {
if (this.m_repositoryComparators == null)
this.m_repositoryComparators = new ArrayList();
this.m_repositoryComparators.add(comparator);
}
public void removeRepositoryComparator(Comparator comparator) {
if (this.m_repositoryComparators != null)
this.m_repositoryComparators.remove(comparator);
}
public static RepositorySetSortContext
getDefaultRepositorySetSortContext() {
return getRepositorySetSortContext(RuperConstants.DEFAULT);
}
public static RepositorySetSortContext
getRepositorySetSortContext(String identifier) {
RepositorySetSortContext context = null;
RepositorySetSortContextIdentifier id =
new RepositorySetSortContextIdentifier(identifier);
try {
if (ReferenceManager.hasReference(id)) {
context =
(RepositorySetSortContext)
ReferenceManager.getReference(
id);
return context;
}
}
catch (NoSuchReferenceException exp) {
Logger.getLog().error(
"No RepositorySetSortContext reference in the
RefMgr ",
exp);
}
return context;
}
public static RepositorySetSortContext getRepositorySetSortContext(
String identifier,
boolean createIfNeeded) {
RepositorySetSortContext context =
getRepositorySetSortContext(identifier);
if (context == null && createIfNeeded) {
context = new RepositorySetSortContext(identifier);
ReferenceManager.createReference(context);
}
return context;
}
public static RepositorySetSortContext
createRepositorySetSortContext(String identifier) {
RepositorySetSortContext context =
new RepositorySetSortContext(identifier);
ReferenceManager.createReference(context);
return context;
}
/**
* @return
*/
public GenericIdentifier getIdentifier() {
return m_identifier;
}
/**
* @param identifier
*/
public void setIdentifier(RepositorySetSortContextIdentifier
identifier) {
m_identifier = identifier;
}
}
--- NEW FILE: RepositoryCapability.java ---
/*
* Created on Aug 26, 2003
*
* To change the template for this generated file go to
* Window>Preferences>Java>Code Generation>Code and Comments
*/
package org.krysalis.ruper2.repository;
import org.krysalis.ruper2.util.Flag;
/**
* @author arb_jack
*/
public class RepositoryCapability extends Flag {
/**
* A repository can be listed, it can tell you what groups and/or
* specifiers it contains.
*/
public static final RepositoryCapability LISTABLE = new
RepositoryCapability("LISTABLE");
/**
* A repository can take a hint
*/
public static final RepositoryCapability HINTABLE = new
RepositoryCapability("HINTABLE");
/**
* A repository can be published to
*/
public static final RepositoryCapability PUBLISHABLE = new
RepositoryCapability("PUBLISHABLE");
/**
* A repository can be deleted from (w/ correct permissions)
*/
public static final RepositoryCapability DELETABLE = new
RepositoryCapability("DELETEABLE");
private RepositoryCapability(final String name) {
super(name);
}
}
--- NEW FILE: RepositoryIdentifier.java ---
/*
* Created on Aug 23, 2003
*
*/
package org.krysalis.ruper2.repository;
import org.krysalis.ruper2.util.identity.GenericIdentifier;
/**
* @author anou_mana
*/
public class RepositoryIdentifier extends GenericIdentifier {
public final static String REPO_URI =
"http://krysalis.org/repository/";;
public final static String REPO_PREFIX = "repo";
public RepositoryIdentifier(String id) {
super(REPO_URI, REPO_PREFIX, id);
}
}
--- NEW FILE: RepositoryAttribute.java ---
/*
* Created on Aug 26, 2003
*
* To change the template for this generated file go to
* Window>Preferences>Java>Code Generation>Code and Comments
*/
package org.krysalis.ruper2.repository;
import org.krysalis.ruper2.util.Flag;
import org.krysalis.ruper2.util.xml.XMLAttribute;
/**
* @author arb_jack
* @author anou_mana
*/
public class RepositoryAttribute extends Flag implements XMLAttribute{
public static final String REPOSITORY_ATTRIBUTE_CLASSNAME =
RepositoryAttribute.class.getName();
/**
* A is 'active' (not worth looking at it).
*/
public static final RepositoryAttribute ACTIVE =
new RepositoryAttribute(RepositoryConstants.ACTIVE);
/**
* A is 'remote' (operations 'cost').
*/
public static final RepositoryAttribute REMOTE =
new RepositoryAttribute(RepositoryConstants.REMOTE);
/**
* A has 'priority' .
*/
public static final RepositoryAttribute PRIORITY =
new RepositoryAttribute(RepositoryConstants.PRIORITY);
/**
* A repository that is hierarchical
*/
public static final RepositoryAttribute HIERARCHICAL =
new RepositoryAttribute("HIERARCHICAL");
public RepositoryAttribute(final String name) {
super(name);
}
}
--- NEW FILE: RepositorySet.java ---
/*
* Created on Sep 2, 2003
*
*/
package org.krysalis.ruper2.repository;
import java.util.ArrayList;
import java.util.Iterator;
import org.krysalis.ruper2.impl.ReferenceManager;
import org.krysalis.ruper2.log.Logger;
import org.krysalis.ruper2.util.RuperConstants;
import org.krysalis.ruper2.util.identity.GenericIdentifier;
import org.krysalis.ruper2.util.reference.NoSuchReferenceException;
import org.krysalis.ruper2.util.reference.Referenceable;
/**
* @author anou_mana
*/
public class RepositorySet implements Referenceable {
public static final String REPOSITORYSET_CLASSNAME =
RepositorySet.class.getName();
private RepositorySetIdentifier m_identifier = null;
private ArrayList m_repositories = new ArrayList();
/**
*
*/
public RepositorySet() {
this(new RepositorySetIdentifier(RuperConstants.UNNAMED));
}
public RepositorySet(ArrayList list) {
this(new RepositorySetIdentifier(RuperConstants.UNNAMED));
this.m_repositories = list;
}
public RepositorySet(String id, ArrayList list) {
this(new RepositorySetIdentifier(id));
this.m_repositories = list;
}
public RepositorySet(Repository target) {
this(new RepositorySetIdentifier(RuperConstants.UNNAMED));
m_repositories.add(target);
}
public RepositorySet(String id, Repository target) {
this(new RepositorySetIdentifier(id));
m_repositories.add(target);
}
/**
*
*/
public RepositorySet(RepositorySetIdentifier identifier) {
m_identifier = identifier;
}
/**
*
*/
public RepositorySet(String identifier) {
m_identifier = new RepositorySetIdentifier(identifier);
}
/**
* @return
*/
public GenericIdentifier getIdentifier() {
return m_identifier;
}
public static RepositorySet getRepositorySet(
String identifier,
final boolean createIfRequired) {
return getRepositorySet(new
RepositorySetIdentifier(identifier),
createIfRequired);
}
public static RepositorySet getRepositorySet(
RepositorySetIdentifier identifier,
final boolean createIfRequired) {
RepositorySet set = null;
if (ReferenceManager.hasReference(identifier)) {
try {
set = (RepositorySet)
ReferenceManager.getReference(identifier);
return set;
}
catch (NoSuchReferenceException exp) {
Logger.getLog().error(
"No RepositorySet reference in the
RefMgr ",
exp);
}
}
if (createIfRequired) {
set = new RepositorySet(identifier);
ReferenceManager.createReference(set);
}
return set;
}
/**
* @return
*/
public ArrayList getRepositories() {
return m_repositories;
}
/**
* @param identifier
*/
public void setIdentifier(RepositorySetIdentifier identifier) {
m_identifier = identifier;
}
/**
* @param list
*/
public void setRepositories(ArrayList list) {
m_repositories = list;
}
public void addRepository(Repository repository) {
this.m_repositories.add(repository);
}
public void removeRepository(Repository repository) {
this.m_repositories.remove(repository);
}
public Object createChild(Class clazz, String tagId, String refId) {
Object object =
ReferenceManager.createReferenceObject(clazz, tagId,
refId);
if (object != null) {
if (object instanceof Repository) {
this.m_repositories.add(object);
}
}
return object;
}
public String toString()
{
StringBuffer buff = new StringBuffer(this.m_identifier.getId());
for(Iterator iter = m_repositories.iterator(); iter.hasNext();){
buff.append( ( (AbstractRepository)iter.next()
).toString() );
}
return buff.toString();
}
}
--- NEW FILE: RepositoryManager.java ---
/*
* Created on Aug 29, 2003
*
*/
package org.krysalis.ruper2.repository;
import java.util.ArrayList;
import java.util.List;
import org.krysalis.ruper2.ResourceUpdater;
import org.krysalis.ruper2.RuperException;
import org.krysalis.ruper2.log.Logger;
import org.krysalis.ruper2.query.ResourceQuery;
import org.krysalis.ruper2.util.RuperConstants;
import org.krysalis.ruper2.util.chainprocess.HandlerChain;
import org.krysalis.ruper2.util.chainprocess.HandlerManager;
import org.krysalis.ruper2.util.select.SelectorHandlerChain;
/**
* @author anou_mana
*/
public class RepositoryManager extends HandlerManager {
private String m_sortContextID = RuperConstants.DEFAULT;
public RepositoryManager() {
super();
configure();
}
private void configure() {
// create the comparator and
HandlerChain comparators = new
HandlerChain(RuperConstants.COMPARATOR);
SelectorHandlerChain selectors =
new SelectorHandlerChain(RuperConstants.SELECTOR);
// first add the selectors
this.addHandlerChain(selectors);
this.addHandlerChain(comparators);
// set the default sort context
// default selectors and comparators are used
setDefaultRepositorySortContext();
}
public void setDefaultRepositorySortContext() {
RepositorySetSortContext repositorySetSortContext =
RepositorySetSortContext.getDefaultRepositorySetSortContext();
if (repositorySetSortContext != null)
setRepositorySortContext(repositorySetSortContext);
}
public void setRepositorySortContext(RepositorySetSortContext
repositorySetSortContext) {
// add the selectors to the chain
SelectorHandlerChain shandlerChain =
(SelectorHandlerChain)
m_handlerChains.get(RuperConstants.SELECTOR);
shandlerChain.setHandlers(
repositorySetSortContext.getRepositorySelectors());
// add the comparators to the chain
HandlerChain handlerChain =
(HandlerChain)
m_handlerChains.get(RuperConstants.COMPARATOR);
handlerChain.setHandlers(
repositorySetSortContext.getRepositoryComparators());
this.m_sortContextID =
repositorySetSortContext.getIdentifier().getId();
}
public RepositorySet getDefaultSortedRepositorySet() {
RepositorySet repositorySet =
RepositorySet.getRepositorySet(
new
RepositorySetIdentifier(RuperConstants.DEFAULT),
true);
try {
repositorySet = getSortedRepositorySet(repositorySet);
}
catch (RuperException exp) {
Logger.getLog().error(
"Error in sorting the default repository set",
exp);
}
return repositorySet;
}
public RepositorySet getSortedRepositorySet(
RepositorySet repositorySet,
RepositorySetSortContext repositorySetSortContext)
throws RuperException {
setRepositorySortContext(repositorySetSortContext);
return getSortedRepositorySet(repositorySet);
}
public RepositorySet getSortedRepositorySet(RepositorySet repositorySet)
throws RuperException {
RepositorySet selectedRepositorySet = null;
// pass it through the chain of handlers - select the
repositories
// select and sort the repository set
List repositories = process(repositorySet.getRepositories());
String repositorySetID =
repositorySet.getIdentifier().getId()
+ "."
+ this.m_sortContextID
+ "."
+ RepositoryConstants.SORTED;
selectedRepositorySet =
new RepositorySet(repositorySetID, (ArrayList)
repositories);
return selectedRepositorySet;
}
public RepositorySet performRepositoryQuery(
final ResourceUpdater ruper,
final ResourceQuery query) {
RepositorySet repositorySet = null;
try {
// check the context
RepositorySetSortContext repositoryContext =
query.getRepositorySetSortContext();
if (repositoryContext != null) {
// if sort context is not same as the one that
already exists
// set it
if (!this
.m_sortContextID
.equals(repositoryContext.getIdentifier().getId())) {
setRepositorySortContext(repositoryContext);
}
}
else {
// no sort context - set the default sort
if
(!this.m_sortContextID.equals(RuperConstants.DEFAULT)) {
this.setDefaultRepositorySortContext();
}
}
// try to get the repository set given by the query
repositorySet = query.getRepositorySet();
if (repositorySet == null) {
repositorySet =
RepositorySet.getRepositorySet(
new
RepositorySetIdentifier(RuperConstants.DEFAULT),
false);
}
if (repositorySet != null) {
repositorySet =
getSortedRepositorySet(repositorySet);
}
}
catch (RuperException exception) {
Logger.getLog().error(
"Unable to perform repository query",
exception);
}
if (repositorySet == null) {
// if not, use the default sorted repository
repositorySet = ruper.getDefaultSortedRepositorySet();
}
return repositorySet;
}
}
--- NEW FILE: RepositorySetSortContextIdentifier.java ---
/*
* Created on Sep 16, 2003
*
*/
package org.krysalis.ruper2.repository;
import org.krysalis.ruper2.util.identity.GenericIdentifier;
/**
* @author anou_mana
*/
public class RepositorySetSortContextIdentifier extends GenericIdentifier {
public final static String REPO_SET_SORT_CONTEXT_URI =
"http://krysalis.org/repository/set/sort/context";;
public final static String REPO_SET_SORT_CONTEXT_PREFIX =
"repoSetSortContext";
public RepositorySetSortContextIdentifier(String id) {
super(REPO_SET_SORT_CONTEXT_URI, REPO_SET_SORT_CONTEXT_PREFIX,
id);
}
}
--- NEW FILE: RepositorySorterConfig.java ---
/*
* Created on Sep 2, 2003
*
*/
package org.krysalis.ruper2.repository;
/**
* @author anou_mana
*/
public class RepositorySorterConfig
{
/**
*
*/
public RepositorySorterConfig()
{
super();
// TODO Auto-generated constructor stub
}
}
--- NEW FILE: DefaultRepository.java ---
/*
* Created on Aug 27, 2003
*/
package org.krysalis.ruper2.repository;
import java.io.File;
import java.util.List;
import org.krysalis.ruper2.impl.ResourceUpdaterContext;
import org.krysalis.ruper2.protocols.VirtualResourceLocator;
import org.krysalis.ruper2.resource.Resource;
import org.krysalis.ruper2.resource.ResourceGroup;
import org.krysalis.ruper2.util.RuperConstants;
import org.krysalis.ruper2.util.select.AllSelector;
import org.krysalis.ruper2.util.select.SelectionHelper;
import org.krysalis.ruper2.util.select.Selector;
import org.krysalis.version.util.SystemUtils;
/**
* @author arb_jack
*/
public class DefaultRepository extends AbstractHierarchicalRepository {
DefaultRepository(String id) {
super(id);
}
public DefaultRepository(String id, final String root) {
super(id, new VirtualResourceLocator(root));
}
public DefaultRepository(
String id,
final String root,
final boolean hierarchical) {
super(id, new VirtualResourceLocator(root),hierarchical);
}
public DefaultRepository(String id, final File root) {
super(id, new VirtualResourceLocator(root));
}
public DefaultRepository(
String id,
final File root,
final boolean hierarchical) {
super(id, new VirtualResourceLocator(root),hierarchical);
}
public DefaultRepository(String id, final VirtualResourceLocator root) {
super(id, root);
}
public DefaultRepository(
String id,
final VirtualResourceLocator root,
final boolean hierarchical) {
super(id, root,hierarchical);
}
public List listGroups(ResourceUpdaterContext context, Selector
selector)
throws Exception {
return context.getProtocolManager().performList(
getRepositoryRoot(),
selector);
}
public List listResources(
final ResourceUpdaterContext context,
final ResourceGroup group,
final Selector selector)
throws Exception {
List results = null;
VirtualResourceLocator container = folderForGroup(group);
if (context.getProtocolManager().checkExists(container)) {
// List the container (by Selector)
// Convert to Resources
// Select the right ones..
List resourceList =
context.getProtocolManager().performList(container, selector);
List analyzedResourceList =
getAnalyzer().determineResources(resourceList);
results = SelectionHelper.select(analyzedResourceList,
selector);
}
else
results = RuperConstants.EMPTY_LIST;
return results;
}
public Resource publishResource(
ResourceUpdaterContext context,
Resource resource)
throws Exception {
Resource publishedResource = new Resource(resource);
//:TODO: Hack for hierarchical
publishedResource.setLocation(
new VirtualResourceLocator(
folderForGroup(resource.getGroup()),
resource.getFilename()));
context.getProtocolManager().performCopy(
resource.getLocation(),
publishedResource.getLocation(),
AllSelector.getInstance());
return publishedResource;
}
public static Repository getLocalTestRepository() {
return new DefaultRepository(
"test",
new VirtualResourceLocator(
new
VirtualResourceLocator(SystemUtils.getCWD()),
"transient/testrepo"));
}
}
--- NEW FILE: AbstractHierarchicalRepository.java ---
/*
* Created on Aug 27, 2003
*/
package org.krysalis.ruper2.repository;
import java.io.File;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.krysalis.ruper2.impl.ResourceUpdaterContext;
import org.krysalis.ruper2.protocols.VirtualResourceLocator;
import org.krysalis.ruper2.resource.Resource;
import org.krysalis.ruper2.resource.ResourceGroup;
import org.krysalis.ruper2.resource.compare.StandardResourceComparisons;
import org.krysalis.ruper2.util.Flag;
import org.krysalis.ruper2.util.RuperConstants;
import org.krysalis.ruper2.util.compare.ComparisonHelper;
import org.krysalis.ruper2.util.select.Selector;
/**
* @author arb_jack
*/
public abstract class AbstractHierarchicalRepository extends AbstractRepository
{
private boolean m_hierarchical = true;
AbstractHierarchicalRepository(String id) {
super(id);
classInit(m_hierarchical);
}
public AbstractHierarchicalRepository(String id, final String root) {
super(id, new VirtualResourceLocator(root));
classInit(m_hierarchical);
}
public AbstractHierarchicalRepository(
String id,
final String root,
final boolean hierarchical) {
super(id, new VirtualResourceLocator(root));
classInit(hierarchical);
}
public AbstractHierarchicalRepository(String id, final File root) {
super(id, new VirtualResourceLocator(root));
classInit(m_hierarchical);
}
public AbstractHierarchicalRepository(
String id,
final File root,
final boolean hierarchical) {
super(id, new VirtualResourceLocator(root));
classInit(hierarchical);
}
public AbstractHierarchicalRepository(String id, final
VirtualResourceLocator root) {
super(id, root);
classInit(m_hierarchical);
}
public AbstractHierarchicalRepository(
String id,
final VirtualResourceLocator root,
final boolean hierarchical) {
super(id, root);
classInit(hierarchical);
}
private void classInit(final boolean hierarchical) {
m_hierarchical = hierarchical;
setRepositoryAttribute(
RepositoryAttribute.HIERARCHICAL,
(hierarchical ? Flag.TRUE : Flag.FALSE));
addCapability(RepositoryCapability.PUBLISHABLE);
addCapability(RepositoryCapability.LISTABLE);
// make the repository active
setRepositoryAttribute(
new RepositoryAttribute(RepositoryConstants.ACTIVE),
RepositoryConstants.TRUE);
}
public List listSpecifiers(
ResourceUpdaterContext context,
ResourceGroup group,
Selector selector)
throws Exception {
List results = null;
List resources = listResources(context, group, selector);
if (!resources.isEmpty()) {
List unique =
ComparisonHelper.sortUnique(
resources,
StandardResourceComparisons.getNameTypeComparatorSet());
if (!unique.isEmpty()) {
results = new ArrayList(unique.size());
for (Iterator i = unique.iterator();
i.hasNext();) {
results.add(((Resource)
i.next()).getSpecifier());
}
}
else
results = RuperConstants.EMPTY_LIST;
}
else
results = RuperConstants.EMPTY_LIST;
return results;
}
public VirtualResourceLocator folderForGroup(ResourceGroup group) {
return m_hierarchical
? new VirtualResourceLocator(
new VirtualResourceLocator(
getRepositoryRoot(),
group.getGroup()),
"jars")
: getRepositoryRoot();
}
}
--- NEW FILE: RepositoryWrapper.java ---
/*
* Created on Sep 4, 2003-
*/
package org.krysalis.ruper2.repository;
import java.util.List;
import org.krysalis.ruper2.impl.ResourceUpdaterContext;
import org.krysalis.ruper2.log.Logger;
import org.krysalis.ruper2.resource.Resource;
import org.krysalis.ruper2.resource.ResourceGroup;
import org.krysalis.ruper2.util.select.Selector;
import org.krysalis.ruper2.util.text.MessageConstants;
import org.krysalis.ruper2.util.text.Messages;
/**
* @author arb_jack
*/
public class RepositoryWrapper {
private Repository m_repository = null;
private ResourceUpdaterContext m_context = null;
public RepositoryWrapper(
Repository repository,
ResourceUpdaterContext context) {
m_repository = repository;
m_context = context;
}
/**
* Return a list of ResourceGroups, using selector
* @param selector
* @return
*/
public List listGroups(Selector selector) throws Exception {
testCapability(RepositoryCapability.LISTABLE);
Logger.getLog().debug(
Messages.getString(
MessageConstants.LIST_GROUPS,
new Object[] { m_repository, selector }));
List groups = null;
try {
groups = m_repository.listGroups(m_context, selector);
}
catch (Exception e) {
throw new RepositoryException(
m_repository,
Messages.getString(
MessageConstants.LIST_GROUPS_FAILED,
new Object[] { m_repository, selector,
e }),
e);
}
return groups;
}
/**
* Return a list of ResourceSpeficiers, using selector
*
* Hmm, is this not just another query?
*
* @param selector
* @return
*/
public List listSpecifiers(ResourceGroup group, Selector selector)
throws Exception {
Logger.getLog().debug(
Messages.getString(
MessageConstants.LIST_SPECIFIERS,
new Object[] { m_repository, group, selector
}));
testCapability(RepositoryCapability.LISTABLE);
List categories = null;
try {
categories =
m_repository.listSpecifiers(m_context, group,
selector);
}
catch (Exception e) {
throw new RepositoryException(
m_repository,
MessageConstants.LIST_SPECIFIERS_FAILED,
e);
}
return categories;
}
/**
* Return a list of contents, using selector
*
* @param selector
* @return
*/
public List listResources(ResourceGroup group, Selector selector)
throws Exception {
Logger.getLog().debug(
Messages.getString(
MessageConstants.LIST_RESOURCES,
new Object[] { m_repository, group, selector
}));
List resources = null;
try {
resources = m_repository.listResources(m_context,
group, selector);
}
catch (Exception e) {
throw new RepositoryException(
m_repository,
Messages.getString(
MessageConstants.LIST_RESOURCES_FAILED,
new Object[] { m_repository, group,
selector, e }),
e);
}
return resources;
}
/**
* Delete a resource from the Repository
*
* @param selector
* @return
*/
public void deleteResource(Resource resource) throws Exception {
Logger.getLog().debug(
Messages.getString(
MessageConstants.DELETE_RESOURCE,
new Object[] { m_repository, resource }));
testCapability(RepositoryCapability.DELETABLE);
try {
m_repository.deleteResource(m_context, resource);
}
catch (Exception e) {
throw new RepositoryException(
m_repository,
Messages.getString(
MessageConstants.DELETE_RESOURCE_FAILED,
new Object[] { m_repository, resource
}),
e);
}
}
/**
* Publish a resource to the repository
*
* @param selector
* @return
*/
public Resource publishResource(Resource resource) throws Exception {
Logger.getLog().debug(
Messages.getString(
MessageConstants.PUBLISH_RESOURCE,
new Object[] { m_repository, resource }));
testCapability(RepositoryCapability.PUBLISHABLE);
Resource publishedResource = null;
try {
publishedResource =
m_repository.publishResource(m_context,
resource);
}
catch (Exception e) {
throw new RepositoryException(m_repository, "Publish
Failed", e);
}
return publishedResource;
}
private void testCapability(RepositoryCapability capability)
throws Exception {
if (!m_repository.hasCapability(capability)) {
throw new RepositoryException(
m_repository,
"Unsupported capability : " + capability);
}
}
public String toString() {
return m_repository.toString();
}
}
--- NEW FILE: RepositoryConstants.java ---
/*
* Created on Aug 29, 2003
*
*/
package org.krysalis.ruper2.repository;
/**
* @author anou_mana
*/
public class RepositoryConstants
{
// Default Repository IDs
public final static String KRYSALIS_ID = "krysalis";
public final static String MAVEN_ID = "maven";
public final static String ACTIVE = "active";
public final static String REMOTE = "remote";
public final static String LOCAL = "local";
public final static String PRIORITY = "priority";
public final static String SORTED = "sorted";
public final static String TRUE = "true";
public final static String FALSE = "false";
}
--- NEW FILE: AbstractRepository.java ---
/*
* Created on Aug 27, 2003
*/
package org.krysalis.ruper2.repository;
import java.util.List;
import org.krysalis.ruper2.files.DefaultResourceFilenameAnalyzer;
import org.krysalis.ruper2.files.ResourceFilenameAnalyzer;
import org.krysalis.ruper2.impl.ReferenceManager;
import org.krysalis.ruper2.impl.ResourceUpdaterContext;
import org.krysalis.ruper2.protocols.VirtualResourceLocator;
import org.krysalis.ruper2.resource.Resource;
import org.krysalis.ruper2.resource.ResourceGroup;
import org.krysalis.ruper2.util.identity.GenericIdentifier;
import org.krysalis.ruper2.util.select.Selectable;
import org.krysalis.ruper2.util.select.Selector;
/**
* @author arb_jack
* @author anou_mana
*/
public abstract class AbstractRepository implements Repository, Selectable {
private RepositoryCapabilitySet m_capabilities = null;
private RepositoryAttributeMap m_attributes = null;
private RepositoryIdentifier m_identifier = null;
private VirtualResourceLocator m_repositoryRoot = null;
private ResourceFilenameAnalyzer m_analyzer = null;
// Initialized?
private boolean m_init = false;
protected AbstractRepository(String id) {
init(id);
}
protected AbstractRepository(String id, VirtualResourceLocator root) {
setVirtualResourceLocator(root);
init(id);
}
private void init(String id){
m_identifier = new RepositoryIdentifier(id);
m_capabilities = new RepositoryCapabilitySet();
m_attributes = new RepositoryAttributeMap();
}
/* (non-Javadoc)
* @see
org.krysalis.ruper2.repository.Repository#getRepositoryIdentifier()
*/
public GenericIdentifier getIdentifier() {
return m_identifier;
}
protected void addCapability(RepositoryCapability capability) {
m_capabilities.add(capability);
}
/* (non-Javadoc)
* @see
org.krysalis.ruper2.repository.Repository#hasCapability(org.krysalis.ruper2.repository.Capability)
*/
public boolean hasCapability(RepositoryCapability capability) {
return m_capabilities.hasCapability(capability);
}
/* (non-Javadoc)
* @see
org.krysalis.ruper2.repository.Repository#hasCapabilities(org.krysalis.ruper2.repository.CapabilitySet)
*/
public boolean hasCapabilities(RepositoryCapabilitySet capabilities) {
return m_capabilities.hasCapabilities(capabilities);
}
/**
* @return
*/
public RepositoryCapabilitySet getCapabilities() {
return m_capabilities;
}
/**
* @return
*/
public Object getSelectionObject() {
return m_identifier;
}
/**
* @return
*/
public VirtualResourceLocator getRepositoryRoot() {
return m_repositoryRoot;
}
public void setRepositoryAttribute(
RepositoryAttribute attribute,
Object value) {
m_attributes.put(attribute, value);
}
public Object getRepositoryAttribute(RepositoryAttribute attribute) {
return m_attributes.get(attribute);
}
/**
* @return
*/
public RepositoryAttributeMap getAttributes() {
return m_attributes;
}
/**
* @return
*/
public ResourceFilenameAnalyzer getAnalyzer() {
return m_analyzer;
}
public List listSpecifiers(
ResourceUpdaterContext context,
ResourceGroup group,
Selector selector)
throws Exception {
throw new RepositoryException(
this,
"Unsupported Capability: " +
RepositoryCapability.LISTABLE);
}
public void deleteResource(
ResourceUpdaterContext context,
Resource resource)
throws Exception {
throw new RepositoryException(
this,
"Unsupported Capability: " +
RepositoryCapability.DELETABLE);
}
public Resource publishResource(
ResourceUpdaterContext context,
Resource resource)
throws Exception {
if (true)
throw new RepositoryException(
this,
"Unsupported Capability: " +
RepositoryCapability.PUBLISHABLE);
return null;
}
public Object createChild(Class clazz, String tagId, String refId) {
return ReferenceManager.createReferenceObject(clazz, tagId,
refId);
}
public void setVirtualResourceLocator(VirtualResourceLocator vrl) {
m_repositoryRoot = vrl;
m_analyzer = new DefaultResourceFilenameAnalyzer(vrl);
}
public String toString() {
return m_identifier.toString();
}
public abstract VirtualResourceLocator folderForGroup(ResourceGroup
group);
}
--- NEW FILE: RepositorySetIdentifier.java ---
/*
* Created on Aug 23, 2003
*
*/
package org.krysalis.ruper2.repository;
import org.krysalis.ruper2.util.identity.GenericIdentifier;
/**
* @author anou_mana
*/
public class RepositorySetIdentifier extends GenericIdentifier {
public final static String REPO_SET_URI =
"http://krysalis.org/repository/set";;
public final static String REPO_SET_PREFIX = "repoSet";
public RepositorySetIdentifier(String id) {
super(REPO_SET_URI, REPO_SET_PREFIX, id);
}
}
--- NEW FILE: Repository.java ---
/*
* Created on Aug 23, 2003
*
*/
package org.krysalis.ruper2.repository;
import java.util.List;
import org.krysalis.ruper2.impl.ResourceUpdaterContext;
import org.krysalis.ruper2.protocols.VirtualResourceLocator;
import org.krysalis.ruper2.resource.Resource;
import org.krysalis.ruper2.resource.ResourceGroup;
import org.krysalis.ruper2.util.reference.Referenceable;
import org.krysalis.ruper2.util.select.Selector;
/**
* @author anou_mana
*/
public interface Repository extends Referenceable {
/**
* Determines if this set has a particular capability.
*
* @param capability The capability to check for.
*/
boolean hasCapability(RepositoryCapability capability);
/**
* Determines if this set has a particular set of capability.
*
* @param capability The capabilities to check for.
*/
boolean hasCapabilities(RepositoryCapabilitySet capabilities);
/**
* Return a map of capabilities.
*
* @param capability The capabilities to check for.
*/
RepositoryAttributeMap getAttributes();
/**
* Return the root for this repository
* @return
*/
VirtualResourceLocator getRepositoryRoot();
/**
* Return a list of ResourceGroups, using selector
*
* @param selector
* @return
*/
List listGroups(ResourceUpdaterContext context, Selector selector)
throws Exception;
/**
* Return a list of ResourceCategories, using selector
* :TODO: Are these groups?
* @param selector
* @return
*/
List listSpecifiers(
ResourceUpdaterContext context,
ResourceGroup group,
Selector selector)
throws Exception;
/**
* Return a list of contents, using selector
*
* @param selector
* @return
*/
List listResources(
ResourceUpdaterContext context,
ResourceGroup group,
Selector selector)
throws Exception;
/**
* Delete a resource from the Repository
*
* @param selector
* @return
*/
void deleteResource(ResourceUpdaterContext context, Resource resource)
throws Exception;
/**
* Publish a resource to the repository
*
* @param selector
* @return
*/
Resource publishResource(ResourceUpdaterContext context, Resource
resource)
throws Exception;
}
--- NEW FILE: RepositoryAttributeMap.java ---
/*
* Created on Aug 26, 2003
*
* To change the template for this generated file go to
* Window>Preferences>Java>Code Generation>Code and Comments
*/
package org.krysalis.ruper2.repository;
import java.util.List;
import org.krysalis.ruper2.util.FlagMap;
/**
* @author arb_jack
*/
public class RepositoryAttributeMap extends FlagMap {
/**
*
*/
public RepositoryAttributeMap() {
super();
}
/**
* @param arg0
*/
public RepositoryAttributeMap(int initialSize) {
super(initialSize);
}
/**
* Determines if this set has a particular attribute.
*/
public boolean hasAttribute(RepositoryAttribute attribute) {
return hasFlag(attribute);
}
/**
* Determines if this set has a particular set of attributes.
*/
public boolean hasAttributes(List attributes) {
return hasFlags(attributes);
}
}
--- NEW FILE: RepositoryCapabilitySet.java ---
/*
* Created on Aug 26, 2003
*
* To change the template for this generated file go to
* Window>Preferences>Java>Code Generation>Code and Comments
*/
package org.krysalis.ruper2.repository;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
* @author arb_jack
*/
public class RepositoryCapabilitySet extends ArrayList {
/**
*
*/
public RepositoryCapabilitySet() {
super();
}
/**
* @param arg0
*/
public RepositoryCapabilitySet(int initialSize) {
super(initialSize);
}
/**
* @param otherCollection -- set to copy from
*/
public RepositoryCapabilitySet(Collection otherCollection) {
super(otherCollection);
}
/**
* Determines if this set has a particular capability.
*
* @param capability The capability to check for.
*/
public boolean hasCapability(RepositoryCapability capability) {
boolean hasIt = false;
for (Iterator i = iterator(); i.hasNext() && !hasIt;) {
hasIt = ((RepositoryCapability)
i.next()).equals(capability);
}
return hasIt;
}
/**
* Determines if this set has a particular set of capability.
*
* @param capability The capabilities to check for.
*/
public boolean hasCapabilities(RepositoryCapabilitySet capabilities) {
boolean hasEm = true;
for (Iterator i = capabilities.iterator(); i.hasNext() &&
hasEm;) {
hasEm &= hasCapability((RepositoryCapability) i.next());
}
return hasEm;
}
}
-------------------------------------------------------
This sf.net email is sponsored by:ThinkGeek
Welcome to geek heaven.
http://thinkgeek.com/sf
|
