source.dussan.org Git - archiva.git/blob

   1 package org.apache.maven.archiva.webdav;
   2
   3 /*
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  You may obtain a copy of the License at
  11  *
  12  *  http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  * KIND, either express or implied.  See the License for the
  18  * specific language governing permissions and limitations
  19  * under the License.
  20  */
  21
  22 import org.apache.jackrabbit.webdav.*;
  23 import org.apache.jackrabbit.webdav.property.*;
  24 import org.apache.jackrabbit.webdav.io.InputContext;
  25 import org.apache.jackrabbit.webdav.io.OutputContext;
  26 import org.apache.jackrabbit.webdav.lock.*;
  27 import org.apache.jackrabbit.util.Text;
  28 import org.apache.commons.io.IOUtils;
  29 import org.apache.commons.io.FileUtils;
  30 import org.apache.maven.archiva.webdav.util.MimeTypes;
  31 import org.apache.maven.archiva.webdav.util.IndexWriter;
  32 import org.joda.time.DateTime;
  33 import org.joda.time.format.DateTimeFormatter;
  34 import org.joda.time.format.ISODateTimeFormat;
  35
  36 import javax.servlet.http.HttpServletResponse;
  37 import java.util.List;
  38 import java.util.ArrayList;
  39 import java.io.*;
  40
  41 /**
  42  * @author <a href="mailto:james@atlassian.com">James William Dumay</a> Portions from the Apache Jackrabbit Project
  43  */
  44 public class ArchivaDavResource
  45     implements DavResource
  46 {
  47     public static final String HIDDEN_PATH_PREFIX = ".";
  48
  49     private final MimeTypes mimeTypes;
  50
  51     private final ArchivaDavResourceLocator locator;
  52
  53     private final DavResourceFactory factory;
  54
  55     private final File localResource;
  56
  57     private final String logicalResource;
  58
  59     private DavPropertySet properties;
  60
  61     private boolean propsInitialized = false;
  62
  63     private LockManager lockManager;
  64
  65     private final DavSession session;
  66
  67     public ArchivaDavResource( String localResource,
  68                                String logicalResource,
  69                                MimeTypes mimeTypes,
  70                                DavSession session,
  71                                ArchivaDavResourceLocator locator,
  72                                DavResourceFactory factory )
  73     {
  74         this.mimeTypes = mimeTypes;
  75         this.localResource = new File( localResource );
  76         this.logicalResource = logicalResource;
  77         this.locator = locator;
  78         this.factory = factory;
  79         this.session = session;
  80         this.properties = new DavPropertySet();
  81     }
  82
  83     public String getContentType()
  84     {
  85         return mimeTypes.getMimeType( localResource.getName() );
  86     }
  87
  88     public String getComplianceClass()
  89     {
  90         return COMPLIANCE_CLASS;
  91     }
  92
  93     public String getSupportedMethods()
  94     {
  95         return METHODS;
  96     }
  97
  98     public boolean exists()
  99     {
 100         return localResource.exists();
 101     }
 102
 103     public boolean isCollection()
 104     {
 105         return localResource.isDirectory();
 106     }
 107
 108     public String getDisplayName()
 109     {
 110         String resPath = getResourcePath();
 111         return ( resPath != null ) ? Text.getName( resPath ) : resPath;
 112     }
 113
 114     public DavResourceLocator getLocator()
 115     {
 116         return locator;
 117     }
 118
 119     public File getLocalResource()
 120     {
 121         return localResource;
 122     }
 123
 124     public String getResourcePath()
 125     {
 126         return locator.getResourcePath();
 127     }
 128
 129     public String getHref()
 130     {
 131         return locator.getHref( isCollection() );
 132     }
 133
 134     public long getModificationTime()
 135     {
 136         initProperties();
 137         return localResource.lastModified();
 138     }
 139
 140     public long getContentLength()
 141     {
 142         initProperties();
 143         return localResource.length();
 144     }
 145
 146     public void spool( OutputContext outputContext )
 147         throws IOException
 148     {
 149         if ( !isCollection() )
 150         {
 151             FileInputStream is = null;
 152             try
 153             {
 154                 outputContext.setContentLength( getContentLength() );
 155                 outputContext.setContentType( getContentType() );
 156
 157                 // Write content to stream
 158                 is = new FileInputStream( localResource );
 159                 IOUtils.copy( is, outputContext.getOutputStream() );
 160             }
 161             finally
 162             {
 163                 IOUtils.closeQuietly( is );
 164             }
 165         }
 166         else
 167         {
 168             IndexWriter writer = new IndexWriter( this, localResource, logicalResource );
 169             writer.write( outputContext );
 170         }
 171     }
 172
 173     public DavPropertyName[] getPropertyNames()
 174     {
 175         return getProperties().getPropertyNames();
 176     }
 177
 178     public DavProperty getProperty( DavPropertyName name )
 179     {
 180         initProperties();
 181         return properties.get( name );
 182     }
 183
 184     public DavPropertySet getProperties()
 185     {
 186         initProperties();
 187         return properties;
 188     }
 189
 190     public void setProperty( DavProperty property )
 191         throws DavException
 192     {
 193     }
 194
 195     public void removeProperty( DavPropertyName propertyName )
 196         throws DavException
 197     {
 198     }
 199
 200     public MultiStatusResponse alterProperties( DavPropertySet setProperties, DavPropertyNameSet removePropertyNames )
 201         throws DavException
 202     {
 203         return null;
 204     }
 205
 206     public MultiStatusResponse alterProperties( List changeList )
 207         throws DavException
 208     {
 209         return null;
 210     }
 211
 212     public DavResource getCollection()
 213     {
 214         DavResource parent = null;
 215         if ( getResourcePath() != null && !getResourcePath().equals( "/" ) )
 216         {
 217             String parentPath = Text.getRelativeParent( getResourcePath(), 1 );
 218             if ( parentPath.equals( "" ) )
 219             {
 220                 parentPath = "/";
 221             }
 222             DavResourceLocator parentloc = locator.getFactory().createResourceLocator( locator.getPrefix(), parentPath );
 223             try
 224             {
 225                 parent = factory.createResource( parentloc, session );
 226             }
 227             catch ( DavException e )
 228             {
 229                 // should not occur
 230             }
 231         }
 232         return parent;
 233     }
 234
 235     public void addMember( DavResource resource, InputContext inputContext )
 236         throws DavException
 237     {
 238         File localFile = new File( localResource, resource.getDisplayName() );
 239         if ( isCollection() && inputContext.hasStream() ) // New File
 240         {
 241             boolean deleteFile = false;
 242             FileOutputStream stream = null;
 243             try
 244             {
 245                 stream = new FileOutputStream( localFile );
 246                 IOUtils.copy( inputContext.getInputStream(), stream );
 247                 if ( inputContext.getContentLength() != localFile.length() )
 248                 {
 249                     deleteFile = true;
 250                     throw new DavException( HttpServletResponse.SC_BAD_REQUEST, "Content Header length was " +
 251                         inputContext.getContentLength() + " but was " + localFile.length() );
 252                 }
 253             }
 254             catch ( IOException e )
 255             {
 256                 throw new DavException( HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e );
 257             }
 258             finally
 259             {
 260                 IOUtils.closeQuietly( stream );
 261                 if ( deleteFile )
 262                 {
 263                     FileUtils.deleteQuietly( localFile );
 264                 }
 265             }
 266         }
 267         else if ( !inputContext.hasStream() && isCollection() ) // New directory
 268         {
 269             localFile.mkdir();
 270         }
 271         else
 272         {
 273             throw new DavException( HttpServletResponse.SC_BAD_REQUEST, "Could not write member " +
 274                 resource.getResourcePath() + " at " + getResourcePath() );
 275         }
 276     }
 277
 278     public DavResourceIterator getMembers()
 279     {
 280         ArrayList list = new ArrayList();
 281         if ( exists() && isCollection() )
 282         {
 283             for ( String item : localResource.list() )
 284             {
 285                 try
 286                 {
 287                     if ( !item.startsWith( HIDDEN_PATH_PREFIX ) )
 288                     {
 289                         String path = locator.getResourcePath() + '/' + item;
 290                         DavResourceLocator resourceLocator =
 291                             locator.getFactory().createResourceLocator( locator.getPrefix(), path );
 292                         DavResource resource = factory.createResource( resourceLocator, session );
 293                         if ( resource != null )
 294                             list.add( resource );
 295                     }
 296                 }
 297                 catch ( DavException e )
 298                 {
 299                     // Should not occur
 300                 }
 301             }
 302         }
 303         return new DavResourceIteratorImpl( list );
 304     }
 305
 306     public void removeMember( DavResource member )
 307         throws DavException
 308     {
 309         File resource = checkDavResourceIsArchivaDavResource( member ).getLocalResource();
 310
 311         if ( resource.exists() )
 312         {
 313             try
 314             {
 315                 if ( resource.isDirectory() )
 316                 {
 317                     FileUtils.deleteDirectory(resource);
 318                 }
 319                 else
 320                 {
 321                     if (!resource.delete())
 322                     {
 323                         throw new IOException("Could not remove file");
 324                     }
 325                 }
 326             }
 327             catch ( IOException e )
 328             {
 329                 throw new DavException( HttpServletResponse.SC_INTERNAL_SERVER_ERROR );
 330             }
 331         }
 332         else
 333         {
 334             throw new DavException( HttpServletResponse.SC_NOT_FOUND );
 335         }
 336     }
 337
 338     public void move( DavResource destination )
 339         throws DavException
 340     {
 341         if ( !exists() )
 342         {
 343             throw new DavException( HttpServletResponse.SC_NOT_FOUND, "Resource to copy does not exist." );
 344         }
 345
 346         try
 347         {
 348             ArchivaDavResource resource = checkDavResourceIsArchivaDavResource( destination );
 349             if ( isCollection() )
 350             {
 351                 FileUtils.moveDirectory( getLocalResource(), resource.getLocalResource() );
 352             }
 353             else
 354             {
 355                 FileUtils.moveFile( getLocalResource(), resource.getLocalResource() );
 356             }
 357         }
 358         catch ( IOException e )
 359         {
 360             throw new DavException( HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e );
 361         }
 362     }
 363
 364     public void copy( DavResource destination, boolean shallow )
 365         throws DavException
 366     {
 367         if ( !exists() )
 368         {
 369             throw new DavException( HttpServletResponse.SC_NOT_FOUND, "Resource to copy does not exist." );
 370         }
 371
 372         if ( shallow && isCollection() )
 373         {
 374             throw new DavException( DavServletResponse.SC_FORBIDDEN, "Unable to perform shallow copy for collection" );
 375         }
 376
 377         try
 378         {
 379             ArchivaDavResource resource = checkDavResourceIsArchivaDavResource( destination );
 380             if ( isCollection() )
 381             {
 382                 FileUtils.copyDirectory( getLocalResource(), resource.getLocalResource() );
 383             }
 384             else
 385             {
 386                 FileUtils.copyFile( getLocalResource(), resource.getLocalResource() );
 387             }
 388         }
 389         catch ( IOException e )
 390         {
 391             throw new DavException( HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e );
 392         }
 393     }
 394
 395     public boolean isLockable( Type type, Scope scope )
 396     {
 397         return Type.WRITE.equals(type) && Scope.EXCLUSIVE.equals(scope);
 398     }
 399
 400     public boolean hasLock( Type type, Scope scope )
 401     {
 402         return getLock(type, scope) != null;
 403     }
 404
 405     public ActiveLock getLock( Type type, Scope scope )
 406     {
 407         ActiveLock lock = null;
 408         if (exists() && Type.WRITE.equals(type) && Scope.EXCLUSIVE.equals(scope))
 409         {
 410             lock = lockManager.getLock(type, scope, this);
 411         }
 412         return lock;
 413     }
 414
 415     public ActiveLock[] getLocks()
 416     {
 417         ActiveLock writeLock = getLock(Type.WRITE, Scope.EXCLUSIVE);
 418         return (writeLock != null) ? new ActiveLock[]{writeLock} : new ActiveLock[0];
 419     }
 420
 421     public ActiveLock lock( LockInfo lockInfo )
 422         throws DavException
 423     {
 424         ActiveLock lock = null;
 425         if (isLockable(lockInfo.getType(), lockInfo.getScope()))
 426         {
 427             lock = lockManager.createLock(lockInfo, this);
 428         }
 429         else
 430         {
 431             throw new DavException(DavServletResponse.SC_PRECONDITION_FAILED, "Unsupported lock type or scope.");
 432         }
 433         return lock;
 434     }
 435
 436     public ActiveLock refreshLock( LockInfo lockInfo, String lockToken )
 437         throws DavException
 438     {
 439         if (!exists()) {
 440             throw new DavException(DavServletResponse.SC_NOT_FOUND);
 441         }
 442         ActiveLock lock = getLock(lockInfo.getType(), lockInfo.getScope());
 443         if (lock == null) {
 444             throw new DavException(DavServletResponse.SC_PRECONDITION_FAILED, "No lock with the given type/scope present on resource " + getResourcePath());
 445         }
 446
 447         lock = lockManager.refreshLock(lockInfo, lockToken, this);
 448
 449         return lock;
 450     }
 451
 452     public void unlock( String lockToken )
 453         throws DavException
 454     {
 455         ActiveLock lock = getLock(Type.WRITE, Scope.EXCLUSIVE);
 456         if (lock == null)
 457         {
 458             throw new DavException(HttpServletResponse.SC_PRECONDITION_FAILED);
 459         }
 460         else if (lock.isLockedByToken(lockToken))
 461         {
 462             lockManager.releaseLock(lockToken, this);
 463         }
 464         else
 465         {
 466             throw new DavException(DavServletResponse.SC_LOCKED);
 467         }
 468     }
 469
 470     public void addLockManager( LockManager lockManager )
 471     {
 472         this.lockManager = lockManager;
 473     }
 474
 475     public DavResourceFactory getFactory()
 476     {
 477         return factory;
 478     }
 479
 480     public DavSession getSession()
 481     {
 482         return session;
 483     }
 484
 485     /**
 486      * Fill the set of properties
 487      */
 488     protected void initProperties()
 489     {
 490         if ( !exists() || propsInitialized )
 491         {
 492             return;
 493         }
 494
 495         // set (or reset) fundamental properties
 496         if ( getDisplayName() != null )
 497         {
 498             properties.add( new DefaultDavProperty( DavPropertyName.DISPLAYNAME, getDisplayName() ) );
 499         }
 500         if ( isCollection() )
 501         {
 502             properties.add( new ResourceType( ResourceType.COLLECTION ) );
 503             // Windows XP support
 504             properties.add( new DefaultDavProperty( DavPropertyName.ISCOLLECTION, "1" ) );
 505         }
 506         else
 507         {
 508             properties.add( new ResourceType( ResourceType.DEFAULT_RESOURCE ) );
 509
 510             // Windows XP support
 511             properties.add( new DefaultDavProperty( DavPropertyName.ISCOLLECTION, "0" ) );
 512         }
 513
 514         // Need to get the ISO8601 date for properties
 515         DateTime dt = new DateTime( localResource.lastModified() );
 516         DateTimeFormatter fmt = ISODateTimeFormat.dateTime();
 517         String modifiedDate = fmt.print( dt );
 518
 519         properties.add( new DefaultDavProperty( DavPropertyName.GETLASTMODIFIED, modifiedDate ) );
 520
 521         properties.add( new DefaultDavProperty( DavPropertyName.CREATIONDATE, modifiedDate ) );
 522
 523         properties.add( new DefaultDavProperty( DavPropertyName.GETCONTENTLENGTH, localResource.length() ) );
 524
 525         propsInitialized = true;
 526     }
 527
 528     private ArchivaDavResource checkDavResourceIsArchivaDavResource( DavResource resource )
 529         throws DavException
 530     {
 531         if ( !( resource instanceof ArchivaDavResource ) )
 532         {
 533             throw new DavException( HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
 534                                     "DavResource is not instance of ArchivaDavResource" );
 535         }
 536         return (ArchivaDavResource) resource;
 537     }
 538 }