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     }
 333
 334     public void move( DavResource destination )
 335         throws DavException
 336     {
 337         if ( !exists() )
 338         {
 339             throw new DavException( HttpServletResponse.SC_NOT_FOUND, "Resource to copy does not exist." );
 340         }
 341
 342         try
 343         {
 344             ArchivaDavResource resource = checkDavResourceIsArchivaDavResource( destination );
 345             if ( isCollection() )
 346             {
 347                 FileUtils.moveDirectory( getLocalResource(), resource.getLocalResource() );
 348             }
 349             else
 350             {
 351                 FileUtils.moveFile( getLocalResource(), resource.getLocalResource() );
 352             }
 353         }
 354         catch ( IOException e )
 355         {
 356             throw new DavException( HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e );
 357         }
 358     }
 359
 360     public void copy( DavResource destination, boolean shallow )
 361         throws DavException
 362     {
 363         if ( !exists() )
 364         {
 365             throw new DavException( HttpServletResponse.SC_NOT_FOUND, "Resource to copy does not exist." );
 366         }
 367
 368         if ( shallow && isCollection() )
 369         {
 370             throw new DavException( DavServletResponse.SC_FORBIDDEN, "Unable to perform shallow copy for collection" );
 371         }
 372
 373         try
 374         {
 375             ArchivaDavResource resource = checkDavResourceIsArchivaDavResource( destination );
 376             if ( isCollection() )
 377             {
 378                 FileUtils.copyDirectory( getLocalResource(), resource.getLocalResource() );
 379             }
 380             else
 381             {
 382                 FileUtils.copyFile( getLocalResource(), resource.getLocalResource() );
 383             }
 384         }
 385         catch ( IOException e )
 386         {
 387             throw new DavException( HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e );
 388         }
 389     }
 390
 391     public boolean isLockable( Type type, Scope scope )
 392     {
 393         return Type.WRITE.equals(type) && Scope.EXCLUSIVE.equals(scope);
 394     }
 395
 396     public boolean hasLock( Type type, Scope scope )
 397     {
 398         return getLock(type, scope) != null;
 399     }
 400
 401     public ActiveLock getLock( Type type, Scope scope )
 402     {
 403         ActiveLock lock = null;
 404         if (exists() && Type.WRITE.equals(type) && Scope.EXCLUSIVE.equals(scope))
 405         {
 406             lock = lockManager.getLock(type, scope, this);
 407         }
 408         return lock;
 409     }
 410
 411     public ActiveLock[] getLocks()
 412     {
 413         ActiveLock writeLock = getLock(Type.WRITE, Scope.EXCLUSIVE);
 414         return (writeLock != null) ? new ActiveLock[]{writeLock} : new ActiveLock[0];
 415     }
 416
 417     public ActiveLock lock( LockInfo lockInfo )
 418         throws DavException
 419     {
 420         ActiveLock lock = null;
 421         if (isLockable(lockInfo.getType(), lockInfo.getScope()))
 422         {
 423             lock = lockManager.createLock(lockInfo, this);
 424         }
 425         else
 426         {
 427             throw new DavException(DavServletResponse.SC_PRECONDITION_FAILED, "Unsupported lock type or scope.");
 428         }
 429         return lock;
 430     }
 431
 432     public ActiveLock refreshLock( LockInfo lockInfo, String lockToken )
 433         throws DavException
 434     {
 435         if (!exists()) {
 436             throw new DavException(DavServletResponse.SC_NOT_FOUND);
 437         }
 438         ActiveLock lock = getLock(lockInfo.getType(), lockInfo.getScope());
 439         if (lock == null) {
 440             throw new DavException(DavServletResponse.SC_PRECONDITION_FAILED, "No lock with the given type/scope present on resource " + getResourcePath());
 441         }
 442
 443         lock = lockManager.refreshLock(lockInfo, lockToken, this);
 444
 445         return lock;
 446     }
 447
 448     public void unlock( String lockToken )
 449         throws DavException
 450     {
 451         ActiveLock lock = getLock(Type.WRITE, Scope.EXCLUSIVE);
 452         if (lock == null)
 453         {
 454             throw new DavException(HttpServletResponse.SC_PRECONDITION_FAILED);
 455         }
 456         else if (lock.isLockedByToken(lockToken))
 457         {
 458             lockManager.releaseLock(lockToken, this);
 459         }
 460         else
 461         {
 462             throw new DavException(DavServletResponse.SC_LOCKED);
 463         }
 464     }
 465
 466     public void addLockManager( LockManager lockManager )
 467     {
 468         this.lockManager = lockManager;
 469     }
 470
 471     public DavResourceFactory getFactory()
 472     {
 473         return factory;
 474     }
 475
 476     public DavSession getSession()
 477     {
 478         return session;
 479     }
 480
 481     /**
 482      * Fill the set of properties
 483      */
 484     protected void initProperties()
 485     {
 486         if ( !exists() || propsInitialized )
 487         {
 488             return;
 489         }
 490
 491         // set (or reset) fundamental properties
 492         if ( getDisplayName() != null )
 493         {
 494             properties.add( new DefaultDavProperty( DavPropertyName.DISPLAYNAME, getDisplayName() ) );
 495         }
 496         if ( isCollection() )
 497         {
 498             properties.add( new ResourceType( ResourceType.COLLECTION ) );
 499             // Windows XP support
 500             properties.add( new DefaultDavProperty( DavPropertyName.ISCOLLECTION, "1" ) );
 501         }
 502         else
 503         {
 504             properties.add( new ResourceType( ResourceType.DEFAULT_RESOURCE ) );
 505
 506             // Windows XP support
 507             properties.add( new DefaultDavProperty( DavPropertyName.ISCOLLECTION, "0" ) );
 508         }
 509
 510         // Need to get the ISO8601 date for properties
 511         DateTime dt = new DateTime( localResource.lastModified() );
 512         DateTimeFormatter fmt = ISODateTimeFormat.dateTime();
 513         String modifiedDate = fmt.print( dt );
 514
 515         properties.add( new DefaultDavProperty( DavPropertyName.GETLASTMODIFIED, modifiedDate ) );
 516
 517         properties.add( new DefaultDavProperty( DavPropertyName.CREATIONDATE, modifiedDate ) );
 518
 519         properties.add( new DefaultDavProperty( DavPropertyName.GETCONTENTLENGTH, localResource.length() ) );
 520
 521         propsInitialized = true;
 522     }
 523
 524     private ArchivaDavResource checkDavResourceIsArchivaDavResource( DavResource resource )
 525         throws DavException
 526     {
 527         if ( !( resource instanceof ArchivaDavResource ) )
 528         {
 529             throw new DavException( HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
 530                                     "DavResource is not instance of ArchivaDavResource" );
 531         }
 532         return (ArchivaDavResource) resource;
 533     }
 534 }