| /* |
| * 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. |
| */ |
| package org.apache.cocoon.components.repository; |
| |
| import java.io.IOException; |
| import java.util.Iterator; |
| |
| import org.apache.avalon.framework.logger.AbstractLogEnabled; |
| import org.apache.avalon.framework.service.ServiceException; |
| import org.apache.avalon.framework.service.ServiceManager; |
| import org.apache.avalon.framework.service.Serviceable; |
| import org.apache.avalon.framework.thread.ThreadSafe; |
| import org.apache.excalibur.source.ModifiableSource; |
| import org.apache.excalibur.source.ModifiableTraversableSource; |
| import org.apache.excalibur.source.Source; |
| import org.apache.excalibur.source.SourceException; |
| import org.apache.excalibur.source.SourceResolver; |
| import org.apache.excalibur.source.SourceUtil; |
| import org.apache.excalibur.source.TraversableSource; |
| |
| /** |
| * SourceRepository implementation. |
| * |
| * @version $Id$ |
| */ |
| public class SourceRepositoryImpl extends AbstractLogEnabled |
| implements Serviceable, ThreadSafe, SourceRepository { |
| |
| private RepositoryInterceptor m_interceptor = new RepositoryInterceptorBase(){}; |
| private SourceResolver m_resolver; |
| |
| |
| // ---------------------------------------------------- lifecycle |
| |
| public SourceRepositoryImpl() { |
| } |
| |
| public void service(ServiceManager manager) throws ServiceException { |
| m_resolver = (SourceResolver) manager.lookup(SourceResolver.ROLE); |
| if (manager.hasService(RepositoryInterceptor.ROLE)) { |
| m_interceptor = (RepositoryInterceptor) manager.lookup(RepositoryInterceptor.ROLE); |
| } |
| } |
| |
| |
| // ---------------------------------------------------- repository operations |
| |
| public int save(String in, String out) throws IOException, SourceException { |
| |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug("save: "+in+"/"+out); |
| } |
| |
| Source source = null; |
| Source destination = null; |
| try { |
| destination = m_resolver.resolveURI(out); |
| |
| if (!(destination instanceof ModifiableSource)) { |
| final String message = |
| "Conflict during save(): protocol is not modifiable."; |
| getLogger().warn(message); |
| return STATUS_CONFLICT; |
| } |
| |
| final boolean exists = destination.exists(); |
| if (!exists) { |
| Source parent = ((TraversableSource) destination).getParent(); |
| if (!parent.exists()) { |
| final String message = |
| "Conflict during save(): parent does not exist."; |
| getLogger().warn(message); |
| return STATUS_CONFLICT; |
| } |
| } |
| |
| if (destination instanceof TraversableSource) { |
| if (((TraversableSource) destination).isCollection()) { |
| final String message = |
| "Conflict during save(): destination is a collection."; |
| getLogger().warn(message); |
| return STATUS_CONFLICT; |
| } |
| } |
| |
| int status; |
| if (exists) { |
| status = STATUS_NO_CONTENT; |
| } |
| else { |
| status = STATUS_CREATED; |
| } |
| |
| source = m_resolver.resolveURI(in); |
| m_interceptor.preStoreSource(destination); |
| SourceUtil.copy(source,destination); |
| m_interceptor.postStoreSource(destination); |
| return status; |
| } |
| catch (IOException e) { |
| getLogger().error("Unexpected exception during save().",e); |
| throw e; |
| } |
| finally { |
| if (source != null) { |
| m_resolver.release(source); |
| } |
| if (destination != null) { |
| m_resolver.release(destination); |
| } |
| } |
| |
| } |
| |
| public int makeCollection(String location) throws IOException, SourceException { |
| |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug("makeCollection: " + location); |
| } |
| |
| Source source = null; |
| Source parent = null; |
| try { |
| source = m_resolver.resolveURI(location); |
| |
| if (source.exists()) { |
| final String message = |
| "makeCollection() is not allowed: the resource already exists."; |
| getLogger().warn(message); |
| return STATUS_NOT_ALLOWED; |
| } |
| |
| if (!(source instanceof ModifiableTraversableSource)) { |
| final String message = |
| "Conflict in makeCollection(): source is not modifiable traversable."; |
| getLogger().warn(message); |
| return STATUS_CONFLICT; |
| } |
| |
| parent = ((TraversableSource) source).getParent(); |
| if (!parent.exists()) { |
| final String message = "Conflict in makeCollection(): parent does not exist."; |
| getLogger().warn(message); |
| return STATUS_CONFLICT; |
| } |
| |
| m_interceptor.preStoreSource(source); |
| ((ModifiableTraversableSource) source).makeCollection(); |
| m_interceptor.postStoreSource(source); |
| return STATUS_CREATED; |
| } |
| catch (IOException e) { |
| getLogger().error("Unexpected exception during makeCollection().",e); |
| throw e; |
| } |
| finally { |
| if (source != null) { |
| m_resolver.release(source); |
| } |
| if (parent != null) { |
| m_resolver.release(parent); |
| } |
| } |
| } |
| |
| /** |
| * Removes a Source and all of its descendants. |
| * |
| * @param location the location of the source to remove. |
| * @return a http status code describing the exit status. |
| * @throws IOException |
| */ |
| public int remove(String location) throws IOException, SourceException { |
| |
| Source source = null; |
| try { |
| source = m_resolver.resolveURI(location); |
| if (!source.exists()) { |
| final String message = |
| "Trying to remove a non-existing source."; |
| getLogger().warn(message); |
| return STATUS_NOT_FOUND; |
| } |
| return remove(source); |
| } |
| catch (IOException e) { |
| getLogger().error("Unexpected exception during remove().",e); |
| throw e; |
| } |
| finally { |
| if (source != null) { |
| m_resolver.release(source); |
| } |
| } |
| |
| } |
| |
| private int remove(Source source) throws SourceException { |
| |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug("remove: " + source.getURI()); |
| } |
| |
| if (!(source instanceof ModifiableSource)) { |
| final String message = |
| "Conflict in remove(): source is not modifiable"; |
| getLogger().warn(message); |
| return STATUS_CONFLICT; |
| } |
| |
| if (source instanceof TraversableSource) { |
| if (((TraversableSource) source).isCollection()) { |
| int status = STATUS_OK; |
| final Iterator iter = ((TraversableSource) source).getChildren().iterator(); |
| while (iter.hasNext()) { |
| status = remove((Source) iter.next()); |
| if (status != STATUS_OK) { |
| return status; |
| } |
| } |
| } |
| } |
| m_interceptor.preRemoveSource(source); |
| ((ModifiableSource) source).delete(); |
| m_interceptor.postRemoveSource(source); |
| return STATUS_OK; |
| } |
| |
| public int move(String from, String to, boolean recurse, boolean overwrite) |
| throws IOException, SourceException { |
| |
| int status = doCopy(from,to,recurse,overwrite); |
| if (status == STATUS_CREATED || status == STATUS_NO_CONTENT) { |
| // TODO: handle partially successful copies |
| remove(from); |
| // TODO: remove properties |
| } |
| return status; |
| } |
| |
| public int copy(String from, String to, boolean recurse, boolean overwrite) |
| throws IOException, SourceException { |
| |
| return doCopy(from,to,recurse,overwrite); |
| |
| } |
| |
| private int doCopy(String from, String to, boolean recurse, boolean overwrite) |
| throws IOException { |
| |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug("copy: " + from + " -> " + to |
| + " (recurse=" + recurse + ", overwrite=" + overwrite + ")"); |
| } |
| |
| if (from != null && from.equals(to)) { |
| final String message = |
| "copy() is forbidden: " + |
| "The source and destination URIs are the same."; |
| getLogger().warn(message); |
| return STATUS_FORBIDDEN; |
| } |
| Source source = null; |
| Source destination = null; |
| try { |
| source = m_resolver.resolveURI(from); |
| destination = m_resolver.resolveURI(to); |
| if (!source.exists()) { |
| final String message = |
| "Trying to copy a non-existing source."; |
| getLogger().warn(message); |
| return STATUS_NOT_FOUND; |
| } |
| int status; |
| if (destination.exists()) { |
| if (!overwrite) { |
| final String message = |
| "Failed precondition in copy(): " + |
| "Destination resource already exists."; |
| getLogger().warn(message); |
| return STATUS_PRECONDITION_FAILED; |
| } |
| remove(destination); |
| status = STATUS_NO_CONTENT; |
| } |
| else { |
| Source parent = null; |
| try { |
| parent = getParent(destination); |
| if (!parent.exists()) { |
| final String message = |
| "Conflict in copy(): " + |
| "A resource cannot be created at the destination " + |
| "until one or more intermediate collections have been " + |
| "created."; |
| getLogger().warn(message); |
| return STATUS_CONFLICT; |
| } |
| } |
| finally { |
| if (parent != null) { |
| m_resolver.release(parent); |
| } |
| } |
| status = STATUS_CREATED; |
| } |
| copy(source,destination,recurse); |
| return status; |
| } |
| catch (IOException e) { |
| getLogger().error("Unexpected exception during copy().",e); |
| throw e; |
| } |
| finally { |
| if (source != null) { |
| m_resolver.release(source); |
| } |
| if (destination != null) { |
| m_resolver.release(destination); |
| } |
| } |
| } |
| |
| private int copy(Source source, Source destination, boolean recurse) |
| throws IOException { |
| |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug("copy: " + source.getURI() + " -> " + destination.getURI()); |
| } |
| |
| if (source instanceof TraversableSource) { |
| final TraversableSource origin = (TraversableSource) source; |
| ModifiableTraversableSource target = null; |
| if (origin.isCollection()) { |
| if (!(destination instanceof ModifiableTraversableSource)) { |
| final String message = "copy() is forbidden: " + |
| "Cannot create a collection at the indicated destination."; |
| getLogger().warn(message); |
| return STATUS_FORBIDDEN; |
| } |
| // TODO: copy properties |
| target = ((ModifiableTraversableSource) destination); |
| m_interceptor.preStoreSource(target); |
| target.makeCollection(); |
| m_interceptor.postStoreSource(target); |
| if (recurse) { |
| Iterator children = origin.getChildren().iterator(); |
| while (children.hasNext()) { |
| TraversableSource child = (TraversableSource) children.next(); |
| /*int status =*/ copy(child,target.getChild(child.getName()),recurse); |
| // TODO: record this status |
| // according to the spec we must continue moving files even though |
| // a part of the move has not succeeded |
| } |
| } |
| return STATUS_CREATED; |
| } |
| } |
| if (destination instanceof ModifiableSource) { |
| // TODO: copy properties |
| m_interceptor.preStoreSource(destination); |
| SourceUtil.copy(source,destination); |
| m_interceptor.postStoreSource(destination); |
| } |
| else { |
| final String message = "copy() is forbidden: " + |
| "Cannot create a resource at the indicated destination."; |
| getLogger().warn(message); |
| return STATUS_FORBIDDEN; |
| } |
| return STATUS_CREATED; |
| } |
| |
| private Source getParent(Source source) throws IOException { |
| if (source instanceof TraversableSource) { |
| return ((TraversableSource) source).getParent(); |
| } |
| else { |
| String uri = source.getURI(); |
| int index = uri.lastIndexOf('/'); |
| if (index != -1) { |
| return m_resolver.resolveURI(uri.substring(index+1)); |
| } |
| } |
| return null; |
| } |
| |
| } |
