krysalis-update/src/java/org/krysalis/depot/update/repository MockRepository.java,NONE,1.1 ApacheRepository.java,NONE,1.1 DefaultRepository.java,NONE,1.1 RepositoryException.java,NONE,1.1 RepositoryConstants.java,NONE,1.1 RepositorySet.java,NONE,1.1 RepositoryCapabilitySet.java,NONE,1.1 AbstractHierarchicalRepository.java,NONE,1.1 RepositoryCapability.java,NONE,1.1 RepositoryAttributeMap.java,NONE,1.1 RepositoryAttribute.java,NONE,1.1 AbstractRepository.java,NONE,1.1
Nick Chalko <[email protected]> Wed, 08 Dec 2004 09:06:31 +0000
| Newsgroups | gmane.comp.krysalis.cvs |
|---|---|
| Message-ID | <[email protected]> |
Update of /cvsroot/krysalis/krysalis-update/src/java/org/krysalis/depot/update/repository
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv24726/src/java/org/krysalis/depot/update/repository
Added Files:
MockRepository.java ApacheRepository.java
DefaultRepository.java RepositoryException.java
RepositoryConstants.java RepositorySet.java
RepositoryCapabilitySet.java
AbstractHierarchicalRepository.java RepositoryCapability.java
RepositoryAttributeMap.java RepositoryAttribute.java
AbstractRepository.java
Log Message:
Copied from the apache incubator.
--- NEW FILE: RepositoryAttributeMap.java ---
/*
* Copyright 2004 The Apache Software Foundation
*
* Licensed 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 org.krysalis.depot.update.repository;
import java.util.List;
import org.krysalis.depot.update.util.flag.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: RepositorySet.java ---
/*
* Copyright 2004 The Apache Software Foundation
*
* Licensed 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 org.krysalis.depot.update.repository;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.krysalis.depot.common.log.Logger;
import org.krysalis.depot.update.Repository;
import org.krysalis.depot.update.impl.ReferenceManager;
import org.krysalis.depot.update.util.UpdateConstants;
import org.krysalis.depot.update.util.identity.GenericIdentifier;
import org.krysalis.depot.update.util.reference.IReferenceable;
import org.krysalis.depot.update.util.reference.NoSuchReferenceException;
/**
* @author anou_mana
*/
public class RepositorySet implements IReferenceable {
public static class Identifier extends GenericIdentifier {
public final static String REPO_SET_URI = "http://apache.org/repository/set";
public final static String REPO_SET_PREFIX = "repoSet";
public Identifier(String id) {
super(REPO_SET_URI, REPO_SET_PREFIX, id);
}
}
public static final String REPOSITORYSET_CLASSNAME = RepositorySet.class.getName();
private RepositorySet.Identifier m_identifier = null;
private List m_repositories = new ArrayList();
/**
*
*/
public RepositorySet() {
this(new RepositorySet.Identifier(UpdateConstants.UNNAMED));
}
public RepositorySet(ArrayList list) {
this(new RepositorySet.Identifier(UpdateConstants.UNNAMED));
this.m_repositories = list;
}
public RepositorySet(String id, ArrayList list) {
this(new RepositorySet.Identifier(id));
this.m_repositories = list;
}
public RepositorySet(Repository target) {
this(new RepositorySet.Identifier(UpdateConstants.UNNAMED));
m_repositories.add(target);
}
public RepositorySet(String id, Repository target) {
this(new RepositorySet.Identifier(id));
m_repositories.add(target);
}
/**
*
*/
public RepositorySet(RepositorySet.Identifier identifier) {
m_identifier = identifier;
}
/**
*
*/
public RepositorySet(String identifier) {
m_identifier = new RepositorySet.Identifier(identifier);
}
/**
* @return
*/
public GenericIdentifier getIdentifier() {
return m_identifier;
}
public static RepositorySet getRepositorySet(String identifier,
final boolean createIfRequired) {
return getRepositorySet(new RepositorySet.Identifier(identifier),
createIfRequired);
}
/**
* @return
*/
public List getRepositories() {
return m_repositories;
}
/**
* @param identifier
*/
public void setIdentifier(RepositorySet.Identifier identifier) {
m_identifier = identifier;
}
/**
* Is this empty (or does it contain repositories)?
*
* @return true = empty
*/
public boolean isEmpty() {
return m_repositories.isEmpty();
}
/**
* @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();
}
public static RepositorySet getDefaultRepositorySet() {
return RepositorySet.getRepositorySet(new RepositorySet.Identifier(
UpdateConstants.DEFAULT), true);
}
public static RepositorySet getRepositorySet(
RepositorySet.Identifier identifier, final boolean createIfRequired) {
RepositorySet set = null;
if (ReferenceManager.hasReference(identifier)) {
try {
set = (RepositorySet) ReferenceManager.getReference(identifier);
} catch (NoSuchReferenceException exp) {
Logger.getLogger().error(
"No RepositorySet reference in the ReferenceManager by id "
+ identifier, exp);
}
}
// Create on demand...
if ((null == set) && createIfRequired) {
set = new RepositorySet(identifier);
ReferenceManager.createReference(set);
}
return set;
}
}
--- NEW FILE: RepositoryException.java ---
/*
* Copyright 2004 The Apache Software Foundation
*
* Licensed 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 org.krysalis.depot.update.repository;
import org.krysalis.depot.update.Repository;
import org.krysalis.depot.update.UpdateException;
/**
* @author arb_jack
*/
public class RepositoryException extends UpdateException {
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;
}
/**
* @return Returns the repository.
*/
public final Repository getRepository() {
return m_repository;
}
}
--- NEW FILE: AbstractRepository.java ---
/*
* Copyright 2004 The Apache Software Foundation
*
* Licensed 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 org.krysalis.depot.update.repository;
import java.io.PrintWriter;
import java.util.List;
import java.util.Map;
import org.krysalis.depot.common.log.Logger;
import org.krysalis.depot.common.util.debug.DebugUtils;
import org.krysalis.depot.common.util.debug.Dumpable;
import org.krysalis.depot.update.ArtifactInstance;
import org.krysalis.depot.update.Repository;
import org.krysalis.depot.update.artifact.ArtifactGroup;
import org.krysalis.depot.update.files.DefaultArtifactFilenameAnalyzer;
import org.krysalis.depot.update.files.DefaultArtifactGroupFilenameAnalyzer;
import org.krysalis.depot.update.files.IArtifactFilenameAnalyzer;
import org.krysalis.depot.update.files.IArtifactGroupFilenameAnalyzer;
import org.krysalis.depot.update.impl.ArtifactUpdaterContext;
import org.krysalis.depot.update.impl.ReferenceManager;
import org.krysalis.depot.update.util.identity.GenericIdentifier;
import org.krysalis.depot.update.util.net.VirtualResourceLocator;
import org.krysalis.depot.update.util.net.select.MatchingVrlSelector;
import org.krysalis.depot.update.util.net.select.ProtocolVrlSelector;
import org.krysalis.depot.update.util.regexp.RegularExpressionHelper;
import org.krysalis.depot.update.util.select.ISelector;
import org.krysalis.depot.update.util.select.logic.AndSelector;
/**
* @author arb_jack
* @author anou_mana
*/
public abstract class AbstractRepository
implements Repository, Dumpable {
private RepositoryCapabilitySet m_capabilities = null;
private RepositoryAttributeMap m_attributes = null;
private Repository.Identifier m_identifier = null;
private VirtualResourceLocator m_repositoryRoot = null;
private IArtifactFilenameAnalyzer m_analyzer = null;
private IArtifactGroupFilenameAnalyzer m_groupAnalyzer = null;
private String m_mirrorDir = 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 Repository.Identifier(id);
m_capabilities = new RepositoryCapabilitySet();
m_attributes = new RepositoryAttributeMap();
}
/* (non-Javadoc)
* @see org.krysalis.depot.update.repository.Repository#getRepositoryIdentifier()
*/
public GenericIdentifier getIdentifier() {
return m_identifier;
}
protected void addCapability(RepositoryCapability capability) {
m_capabilities.add(capability);
}
/* (non-Javadoc)
* @see org.krysalis.depot.update.repository.Repository#hasCapability(org.krysalis.depot.update.repository.Capability)
*/
public boolean hasCapability(RepositoryCapability capability) {
return m_capabilities.hasCapability(capability);
}
/* (non-Javadoc)
* @see org.krysalis.depot.update.repository.Repository#hasCapabilities(org.krysalis.depot.update.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 Map getAttributes() {
return m_attributes;
}
/**
* @return
*/
public IArtifactFilenameAnalyzer getAnalyzer() {
return m_analyzer;
}
/**
* @return
*/
public IArtifactGroupFilenameAnalyzer getGroupAnalyzer() {
return m_groupAnalyzer;
}
public List listArtifacts(
ArtifactUpdaterContext context,
ArtifactGroup group,
ISelector selector)
throws Exception {
throw new RepositoryException(
this,
"Unsupported Capability: "
+ RepositoryCapability.LISTABLE_ARTIFACTS);
}
public void deleteArtifact(
ArtifactUpdaterContext context,
ArtifactInstance artifact)
throws Exception {
throw new RepositoryException(
this,
"Unsupported Capability: " + RepositoryCapability.DELETABLE);
}
public ArtifactInstance publishArtifact(
ArtifactUpdaterContext context,
ArtifactInstance artifact)
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 DefaultArtifactFilenameAnalyzer(vrl);
m_groupAnalyzer = new DefaultArtifactGroupFilenameAnalyzer(vrl);
}
public String toString() {
return m_identifier.toString();
}
public void dump(PrintWriter out, int depth, boolean verbose) {
String indent = DebugUtils.getIndent(depth);
out.print(indent);
out.println("Repository: " + m_identifier);
out.print(indent);
out.println("Root: " + m_repositoryRoot);
DebugUtils.dump(
out,
depth + 1,
"Capabilities",
verbose,
m_capabilities);
DebugUtils.dump(out, depth + 1, "Atributes", verbose, m_attributes);
}
public abstract VirtualResourceLocator folderForGroup(ArtifactGroup group);
public void initialize(ArtifactUpdaterContext context) throws Exception {
if (m_init)
return;
if (context.getProtocolManager().checkExists(getRepositoryRoot())) {
if (null != m_mirrorDir) {
// Determine the list of mirrors:
// but:
// Ensure we support protocol
// AND
// Ensure it is a mirror (not random link)
List mirrorVRLs =
context.getProtocolManager().performList(
getMirrorRoot(),
new AndSelector(
new ProtocolVrlSelector(
context
.getProtocolManager()
.getSupportedSourceProtocols()),
new MatchingVrlSelector(
RegularExpressionHelper.endsWith(
m_mirrorDir))));
// Select first, it ought be 'closest'
if (mirrorVRLs.size() > 0) {
VirtualResourceLocator mirrorSite =
(VirtualResourceLocator) (mirrorVRLs.get(0));
Logger.getLogger().info("Selected mirror : " + mirrorSite);
//
// Assume this identity
//
m_repositoryRoot = mirrorSite;
}
else
throw new RepositoryException(
this,
"Unable to get mirror site.");
}
}
m_init = true;
}
public VirtualResourceLocator getMirrorRoot() {
return (null != m_mirrorDir)
? new VirtualResourceLocator(getRepositoryRoot(), m_mirrorDir)
: getRepositoryRoot();
}
/**
* @return
*/
public String getMirrorDir() {
return m_mirrorDir;
}
/**
* @param string
*/
public void setMirrorDir(String string) {
m_mirrorDir = string;
}
}
--- NEW FILE: AbstractHierarchicalRepository.java ---
/*
* Copyright 2004 The Apache Software Foundation
*
* Licensed 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 org.krysalis.depot.update.repository;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import org.krysalis.depot.update.ArtifactInstance;
import org.krysalis.depot.update.RepositoryManifest;
import org.krysalis.depot.update.artifact.ArtifactGroup;
import org.krysalis.depot.update.artifact.compare.StandardArtifactComparisons;
import org.krysalis.depot.update.impl.ArtifactUpdaterContext;
import org.krysalis.depot.update.util.UpdateConstants;
import org.krysalis.depot.update.util.compare.ComparisonHelper;
import org.krysalis.depot.update.util.flag.Flag;
import org.krysalis.depot.update.util.io.ResolvedFile;
import org.krysalis.depot.update.util.net.VirtualResourceLocator;
import org.krysalis.depot.update.util.select.ISelector;
/**
* @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 ResolvedFile root) {
super(id, new VirtualResourceLocator(root));
classInit(m_hierarchical);
}
public AbstractHierarchicalRepository(
String id,
final ResolvedFile 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);
//
// :TODO: Right now we can't determine groups from
// flat repos. We could, be getting contents and
// using names as unique groups. Todo later...
//
if (hierarchical)
addCapability(RepositoryCapability.LISTABLE_GROUPS);
addCapability(RepositoryCapability.GROUP_MANIFEST);
addCapability(RepositoryCapability.LISTABLE_ARTIFACTS);
// Assuming credentials/protocol allow...
addCapability(RepositoryCapability.DELETABLE);
// make the repository active
setRepositoryAttribute(RepositoryAttribute.ACTIVE, Flag.TRUE);
}
/**
* Get the separate artifacts housed within this group.
*
* @deprecated this method is useless
*/
public List listArtifacts(
ArtifactUpdaterContext context,
ArtifactGroup group,
ISelector selector)
throws Exception {
List results = null;
// Get a lsit of all instances, and then filter for
// uniquenes (to get Artifacts)
List artifacts = listInstances(context, group, selector);
if (!artifacts.isEmpty()) {
List unique =
ComparisonHelper.sortUnique(
artifacts,
StandardArtifactComparisons
.getNameTypeComparatorSequence());
if (!unique.isEmpty()) {
//
// Sort now by name/type/version, just to be 'pretty'
// :TODO: Ought wrapper do something like this, not
//
//
Collections.sort(
unique,
StandardArtifactComparisons
.getNameTypeVersionComparatorSequence());
results = new ArrayList(unique.size());
for (Iterator i = unique.iterator(); i.hasNext();) {
results.add(((ArtifactInstance) i.next()).getArtifact());
}
}
else
results = UpdateConstants.EMPTY_LIST;
}
else
results = UpdateConstants.EMPTY_LIST;
return results;
}
/**
* @deprecated uses a buggy method
*/
public RepositoryManifest getManifest(
ArtifactUpdaterContext context,
ArtifactGroup group,
ISelector selector)
throws Exception {
return new RepositoryManifest(listArtifacts(context, group, selector));
}
public VirtualResourceLocator folderForGroup(ArtifactGroup group) {
return m_hierarchical
? new VirtualResourceLocator(
new VirtualResourceLocator(
getRepositoryRoot(),
group.getName()),
"jars/")
: getRepositoryRoot();
}
/**
* @return
*/
public boolean isHierarchical() {
return m_hierarchical;
}
/**
* @param b
*/
public void setHierarchical(boolean b) {
m_hierarchical = b;
}
}
--- NEW FILE: MockRepository.java ---
/*
* Copyright 2004 The Apache Software Foundation
*
* Licensed 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 org.krysalis.depot.update.repository;
import java.util.ArrayList;
import java.util.List;
import org.krysalis.depot.update.ArtifactInstance;
import org.krysalis.depot.update.Repository;
import org.krysalis.depot.update.artifact.ArtifactGroup;
import org.krysalis.depot.update.artifact.ArtifactLocator;
import org.krysalis.depot.update.impl.ArtifactUpdaterContext;
import org.krysalis.depot.update.util.net.VirtualResourceLocator;
import org.krysalis.depot.update.util.select.ISelector;
import org.krysalis.depot.update.util.select.SelectionHelper;
/**
* @author arb_jack
*/
public class MockRepository extends AbstractHierarchicalRepository {
//private final static List EMPTY_LIST = new ArrayList();
MockRepository(String id) {
super(id, new VirtualResourceLocator("http://mockrepo.org/stuff"), true);
}
public List listGroups(ArtifactUpdaterContext context, ISelector selector)
throws Exception {
List groups = new ArrayList();
// :TODO: Populate with some test groups...
groups.add(ArtifactGroup.getTestGroup("test1"));
groups.add(ArtifactGroup.getTestGroup("test2"));
groups.add(ArtifactGroup.getTestGroup("test3"));
return groups;
}
public List listInstances(final ArtifactUpdaterContext context,
final ArtifactGroup group, final ISelector selector)
throws Exception {
List results = null;
folderForGroup(group);
List instanceList = null;//ArtifactInstanceTest.getTestArtifactList(group.getName(), 10);
results = SelectionHelper.select(instanceList, selector);
return results;
}
public ArtifactInstance publishArtifact(ArtifactUpdaterContext context,
ArtifactInstance instance) throws Exception {
ArtifactInstance publishedArtifact = new ArtifactInstance(
instance.getArtifact(),
new ArtifactLocator(instance.getLocator().getFilename(),
instance.getLocator().getExtension(),
new VirtualResourceLocator(
folderForGroup(instance.getArtifact().getGroup()),
instance.getLocator().getFilename())));
return publishedArtifact;
}
public void initialize(ArtifactUpdaterContext context) throws Exception {
}
public static Repository getMockRepository() {
return new MockRepository("mockrepo");
}
}
--- NEW FILE: RepositoryConstants.java ---
/*
* Copyright 2004 The Apache Software Foundation
*
* Licensed 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 org.krysalis.depot.update.repository;
/**
* @author anou_mana
*/
public class RepositoryConstants
{
// Default Repository IDs
public final static String APACHE_ID = "apache";
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";
}
--- NEW FILE: RepositoryCapabilitySet.java ---
/*
* Copyright 2004 The Apache Software Foundation
*
* Licensed 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 org.krysalis.depot.update.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;
}
}
--- NEW FILE: ApacheRepository.java ---
/*
* Copyright 2004 The Apache Software Foundation
*
* Licensed 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 org.krysalis.depot.update.repository;
import java.util.List;
import org.krysalis.depot.update.RepositoryManifest;
import org.krysalis.depot.update.artifact.ArtifactGroup;
import org.krysalis.depot.update.impl.ArtifactUpdaterContext;
import org.krysalis.depot.update.util.net.VirtualResourceLocator;
import org.krysalis.depot.update.util.select.ISelector;
/**
* An apache style repository as decribed in <a
* href="http://nagoya.apache.org/wiki/apachewiki.cgi?ASFRepository">ASF
* Repository Wiki </a>
*/
public final class ApacheRepository extends AbstractRepository {
/**
* @param id
*/
public ApacheRepository(String id) {
super(id);
}
/**
* @param id
* @param root
*/
public ApacheRepository(String id, VirtualResourceLocator root) {
super(id, root);
// TODO Auto-generated constructor stub
}
/*
* (non-Javadoc)
*
* @see org.krysalis.depot.update.repository.AbstractRepository#folderForGroup(org.krysalis.depot.update.resource.ResourceGroup)
*/
public VirtualResourceLocator folderForGroup(ArtifactGroup group) {
// TODO Auto-generated method stub
return null;
}
/*
* (non-Javadoc)
*
* @see org.krysalis.depot.update.repository.IRepository#listGroups(org.krysalis.depot.update.impl.ResourceUpdaterContext,
* org.krysalis.depot.update.util.select.ISelector)
*/
public List listGroups(ArtifactUpdaterContext context, ISelector selector)
throws Exception {
// TODO Auto-generated method stub
return null;
}
/*
* (non-Javadoc)
*
* @see org.krysalis.depot.update.repository.IRepository#getManifest(org.krysalis.depot.update.impl.ResourceUpdaterContext,
* org.krysalis.depot.update.resource.ResourceGroup,
* org.krysalis.depot.update.util.select.ISelector)
*/
public RepositoryManifest getManifest(ArtifactUpdaterContext context,
ArtifactGroup group, ISelector selector) throws Exception {
// :TODO: Auto-generated method stub
return null;
}
/*
* (non-Javadoc)
*
* @see org.krysalis.depot.update.repository.IRepository#listArtifacts(org.krysalis.depot.update.impl.ResourceUpdaterContext,
* org.krysalis.depot.update.resource.ResourceGroup,
* org.krysalis.depot.update.util.select.ISelector)
*/
public List listInstances(ArtifactUpdaterContext context,
ArtifactGroup group, ISelector selector) throws Exception {
// :TODO: Auto-generated method stub
return null;
}
}
--- NEW FILE: RepositoryAttribute.java ---
/*
* Copyright 2004 The Apache Software Foundation
*
* Licensed 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 org.krysalis.depot.update.repository;
import org.krysalis.depot.update.util.flag.Flag;
import org.krysalis.depot.update.util.xml.IXMLAttribute;
/**
* @author arb_jack
* @author anou_mana
*/
public class RepositoryAttribute extends Flag implements IXMLAttribute{
public static final String REPOSITORY_ATTRIBUTE_CLASSNAME =
RepositoryAttribute.class.getName();
/**
* A is 'active' (not worth looking at it if not active).
*
* Allows us to keep configuration, but inactivate it.
*/
public static final RepositoryAttribute ACTIVE =
new RepositoryAttribute(RepositoryConstants.ACTIVE);
/**
* A is 'remote' (operations 'cost' network usage).
*/
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");
private RepositoryAttribute(final String name) {
super(name);
}
}
--- NEW FILE: RepositoryCapability.java ---
/*
* Copyright 2004 The Apache Software Foundation
*
* Licensed 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 org.krysalis.depot.update.repository;
import org.krysalis.depot.update.util.flag.Flag;
/**
* @author arb_jack
*/
public class RepositoryCapability extends Flag {
/**
* A repository's groups can be listed.
*/
public static final RepositoryCapability LISTABLE_GROUPS = new RepositoryCapability("LISTABLE_GROUPS");
/**
* A repository group's artifacts can be listed.
*/
public static final RepositoryCapability LISTABLE_ARTIFACTS = new RepositoryCapability("LISTABLE_ARTIFACTS");
/**
* A repository group's manifest can be acquired.
*/
public static final RepositoryCapability GROUP_MANIFEST = new RepositoryCapability("GROUP_MANIFEST");
/**
* 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("DELETABLE");
private RepositoryCapability(final String name) {
super(name);
}
}
--- NEW FILE: DefaultRepository.java ---
/*
* Copyright 2004 The Apache Software Foundation
*
* Licensed 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 org.krysalis.depot.update.repository;
import java.util.List;
import org.krysalis.depot.common.log.Logger;
import org.krysalis.depot.common.util.SystemUtils;
import org.krysalis.depot.update.ArtifactInstance;
import org.krysalis.depot.update.Repository;
import org.krysalis.depot.update.artifact.ArtifactGroup;
import org.krysalis.depot.update.artifact.ArtifactLocator;
import org.krysalis.depot.update.impl.ArtifactUpdaterContext;
import org.krysalis.depot.update.impl.ReferenceManager;
import org.krysalis.depot.update.util.UpdateConstants;
import org.krysalis.depot.update.util.io.ResolvedFile;
import org.krysalis.depot.update.util.net.VirtualResourceLocator;
import org.krysalis.depot.update.util.net.select.ChildVrlSelector;
import org.krysalis.depot.update.util.reference.NoSuchReferenceException;
import org.krysalis.depot.update.util.select.AllSelector;
import org.krysalis.depot.update.util.select.ISelector;
import org.krysalis.depot.update.util.select.SelectionHelper;
import org.krysalis.depot.update.util.select.logic.AndSelector;
/**
* @author arb_jack
*/
public class DefaultRepository extends AbstractHierarchicalRepository {
public static final String DEFAULT_REPOSITORY_CLASSNAME = DefaultRepository.class.getName();
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 ResolvedFile root) {
super(id, new VirtualResourceLocator(root));
}
public DefaultRepository(String id, final ResolvedFile 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(ArtifactUpdaterContext context, ISelector selector)
throws Exception {
List results = null;
if (context.getProtocolManager().checkExists(getRepositoryRoot())) {
List groupVRLs = context.getProtocolManager().performList(
getRepositoryRoot(),
new AndSelector(new ChildVrlSelector(getRepositoryRoot()),
selector));
if (!groupVRLs.isEmpty()) {
List analyzedGroupList = getGroupAnalyzer().determineGroups(
groupVRLs);
results = SelectionHelper.select(analyzedGroupList, selector);
} else
results = UpdateConstants.EMPTY_LIST;
} else
results = UpdateConstants.EMPTY_LIST;
return results;
}
public List listInstances(final ArtifactUpdaterContext context,
final ArtifactGroup group, final ISelector 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 artifactList = context.getProtocolManager().performList(
container, new ChildVrlSelector(container));
List analyzedGroupList = getAnalyzer().determineArtifacts(
artifactList);
results = SelectionHelper.select(analyzedGroupList, selector);
} else
results = UpdateConstants.EMPTY_LIST;
return results;
}
public ArtifactInstance publishArtifact(ArtifactUpdaterContext context,
ArtifactInstance instance) throws Exception {
// Create the 'remote' instance
ArtifactInstance publishedInstance = new ArtifactInstance(
instance.getArtifact(),
new ArtifactLocator(
instance.getLocator().getFilename(),
instance.getLocator().getExtension(),
new VirtualResourceLocator(
folderForGroup(instance.getArtifact().getGroup()),
instance.getLocator().getFilename())));
// Perform copy
context.getProtocolManager().performCopy(
instance.getLocator().getLocation(),
publishedInstance.getLocator().getLocation(),
AllSelector.getInstance());
return publishedInstance;
}
public void deleteArtifact(ArtifactUpdaterContext context,
ArtifactInstance instance) throws Exception {
// Perform copy
context.getProtocolManager().performDelete(
instance.getLocator().getLocation(), AllSelector.getInstance());
}
public static Repository getLocalTestRepository() {
return new DefaultRepository(
"test",
new VirtualResourceLocator(
new VirtualResourceLocator(
ResolvedFile.resolve(SystemUtils.getCWD().getAbsolutePath())),
"src/artifacts/test/repo"));
}
public static Repository getRepository(String identifier) {
return getRepository(new Repository.Identifier(identifier), false);
}
public static Repository getRepository(String identifier,
final boolean createIfRequired) {
return getRepository(new Repository.Identifier(identifier),
createIfRequired);
}
public static Repository getRepository(Repository.Identifier identifier,
final boolean createIfRequired) {
Repository repo = null;
if (ReferenceManager.hasReference(identifier)) {
try {
repo = (Repository) ReferenceManager.getReference(identifier);
} catch (NoSuchReferenceException exp) {
Logger.getLogger().error(
"No Repository reference in the ReferenceManager: ",
exp);
}
}
// Create on demand...
if ((null == repo) && createIfRequired) {
//
// :TODO: Hmm, this is bogus, there is no root...
//
repo = new DefaultRepository(identifier.getId());
ReferenceManager.createReference(repo);
}
return repo;
}
}
-------------------------------------------------------
SF email is sponsored by - The IT Product Guide
Read honest & candid reviews on hundreds of IT Products from real users.
Discover which products truly live up to the hype. Start reading now.
http://productguide.itmanagersjournal.com/