Java tutorial
package org.apache.archiva.repository.content.maven2; /* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. */ import org.apache.archiva.model.ArtifactReference; import org.apache.archiva.repository.ManagedRepositoryContent; import org.apache.archiva.repository.content.PathParser; import org.apache.archiva.repository.layout.LayoutException; import org.apache.archiva.repository.metadata.MetadataTools; import org.apache.commons.lang.StringUtils; /** * RepositoryRequest is used to determine the type of request that is incoming, and convert it to an appropriate * ArtifactReference. */ public class RepositoryRequest { private PathParser defaultPathParser = new DefaultPathParser(); public RepositoryRequest() { // no op } /** * Takes an incoming requested path (in "/" format) and gleans the layout * and ArtifactReference appropriate for that content. * * @param requestedPath the relative path to the content. * @return the ArtifactReference for the requestedPath. * @throws org.apache.archiva.repository.layout.LayoutException if the request path is not layout valid. */ public ArtifactReference toArtifactReference(String requestedPath) throws LayoutException { if (StringUtils.isBlank(requestedPath)) { throw new LayoutException("Blank request path is not a valid."); } String path = requestedPath; while (path.startsWith("/")) { path = path.substring(1); // Only slash? that's bad, mmm-kay? if ("/".equals(path)) { throw new LayoutException("Invalid request path: Slash only."); } } if (isDefault(path)) { return defaultPathParser.toArtifactReference(path); } else if (isLegacy(path)) { throw new LayoutException("Legacy Maven1 repository not supported anymore."); } else { throw new LayoutException("Not a valid request path layout, too short."); } } /** * <p> * Tests the path to see if it conforms to the expectations of a metadata request. * </p> * <p> * NOTE: This does a cursory check on the path's last element. A result of true * from this method is not a guarantee that the metadata is in a valid format, or * that it even contains data. * </p> * * @param requestedPath the path to test. * @return true if the requestedPath is likely a metadata request. */ public boolean isMetadata(String requestedPath) { return requestedPath.endsWith("/" + MetadataTools.MAVEN_METADATA); } /** * @param requestedPath * @return true if the requestedPath is likely an archetype catalog request. */ public boolean isArchetypeCatalog(String requestedPath) { return requestedPath.endsWith("/" + MetadataTools.MAVEN_ARCHETYPE_CATALOG); } /** * <p> * Tests the path to see if it conforms to the expectations of a support file request. * </p> * <p> * Tests for <code>.sha1</code>, <code>.md5</code>, <code>.asc</code>, and <code>.php</code>. * </p> * <p> * NOTE: This does a cursory check on the path's extension only. A result of true * from this method is not a guarantee that the support resource is in a valid format, or * that it even contains data. * </p> * * @param requestedPath the path to test. * @return true if the requestedPath is likely that of a support file request. */ public boolean isSupportFile(String requestedPath) { int idx = requestedPath.lastIndexOf('.'); if (idx <= 0) { return false; } String ext = requestedPath.substring(idx); return (".sha1".equals(ext) || ".md5".equals(ext) || ".asc".equals(ext) || ".pgp".equals(ext)); } public boolean isMetadataSupportFile(String requestedPath) { if (isSupportFile(requestedPath)) { String basefilePath = StringUtils.substring(requestedPath, 0, requestedPath.lastIndexOf('.')); if (isMetadata(basefilePath)) { return true; } } return false; } /** * <p> * Tests the path to see if it conforms to the expectations of a default layout request. * </p> * <p> * NOTE: This does a cursory check on the count of path elements only. A result of * true from this method is not a guarantee that the path sections are valid and * can be resolved to an artifact reference. use {@link #toArtifactReference(String)} * if you want a more complete analysis of the validity of the path. * </p> * * @param requestedPath the path to test. * @return true if the requestedPath is likely that of a default layout request. */ public boolean isDefault(String requestedPath) { if (StringUtils.isBlank(requestedPath)) { return false; } String pathParts[] = StringUtils.splitPreserveAllTokens(requestedPath, '/'); if (pathParts.length > 3) { return true; } else if (pathParts.length == 3) { // check if artifact-level metadata (ex. eclipse/jdtcore/maven-metadata.xml) if (isMetadata(requestedPath)) { return true; } else { // check if checksum of artifact-level metadata (ex. eclipse/jdtcore/maven-metadata.xml.sha1) int idx = requestedPath.lastIndexOf('.'); if (idx > 0) { String base = requestedPath.substring(0, idx); if (isMetadata(base) && isSupportFile(requestedPath)) { return true; } } return false; } } else { return false; } } /** * <p> * Tests the path to see if it conforms to the expectations of a legacy layout request. * </p> * <p> * NOTE: This does a cursory check on the count of path elements only. A result of * true from this method is not a guarantee that the path sections are valid and * can be resolved to an artifact reference. use {@link #toArtifactReference(String)} * if you want a more complete analysis of the validity of the path. * </p> * * @param requestedPath the path to test. * @return true if the requestedPath is likely that of a legacy layout request. */ public boolean isLegacy(String requestedPath) { if (StringUtils.isBlank(requestedPath)) { return false; } String pathParts[] = StringUtils.splitPreserveAllTokens(requestedPath, '/'); return pathParts.length == 3; } /** * Adjust the requestedPath to conform to the native layout of the provided {@link org.apache.archiva.repository.ManagedRepositoryContent}. * * @param requestedPath the incoming requested path. * @param repository the repository to adjust to. * @return the adjusted (to native) path. * @throws org.apache.archiva.repository.layout.LayoutException if the path cannot be parsed. */ public String toNativePath(String requestedPath, ManagedRepositoryContent repository) throws LayoutException { if (StringUtils.isBlank(requestedPath)) { throw new LayoutException("Request Path is blank."); } String referencedResource = requestedPath; // No checksum by default. String supportfile = ""; // Figure out support file, and actual referencedResource. if (isSupportFile(requestedPath)) { int idx = requestedPath.lastIndexOf('.'); referencedResource = requestedPath.substring(0, idx); supportfile = requestedPath.substring(idx); } if (isMetadata(referencedResource)) { /* Nothing to translate. * Default layout is the only layout that can contain maven-metadata.xml files, and * if the managedRepository is layout legacy, this request would never occur. */ return requestedPath; } // Treat as an artifact reference. ArtifactReference ref = toArtifactReference(referencedResource); String adjustedPath = repository.toPath(ref); return adjustedPath + supportfile; } }