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 static final String METHODS =
  60         "OPTIONS, GET, HEAD, POST, TRACE, PROPFIND, PROPPATCH, MKCOL, COPY, PUT, DELETE, MOVE";
  61
  62     private static final String COMPLIANCE_CLASS = "1";
  63
  64     private DavPropertySet properties;
  65
  66     private boolean propsInitialized = false;
  67
  68     public ArchivaDavResource( String localResource, String logicalResource, MimeTypes mimeTypes,
  69                                ArchivaDavResourceLocator locator, DavResourceFactory factory )
  70     {
  71         this.mimeTypes = mimeTypes;
  72         this.localResource = new File( localResource );
  73         this.logicalResource = logicalResource;
  74         this.locator = locator;
  75         this.factory = factory;
  76         this.properties = new DavPropertySet();
  77     }
  78
  79     public String getContentType()
  80     {
  81         return mimeTypes.getMimeType( localResource.getName() );
  82     }
  83
  84     public String getComplianceClass()
  85     {
  86         return COMPLIANCE_CLASS;
  87     }
  88
  89     public String getSupportedMethods()
  90     {
  91         return METHODS;
  92     }
  93
  94     public boolean exists()
  95     {
  96         return localResource.exists();
  97     }
  98
  99     public boolean isCollection()
 100     {
 101         return localResource.isDirectory();
 102     }
 103
 104     public String getDisplayName()
 105     {
 106         String resPath = getResourcePath();
 107         return ( resPath != null ) ? Text.getName( resPath ) : resPath;
 108     }
 109
 110     public DavResourceLocator getLocator()
 111     {
 112         return locator;
 113     }
 114
 115     public File getLocalResource()
 116     {
 117         return localResource;
 118     }
 119
 120     public String getResourcePath()
 121     {
 122         return locator.getResourcePath();
 123     }
 124
 125     public String getHref()
 126     {
 127         return locator.getHref( isCollection() );
 128     }
 129
 130     public long getModificationTime()
 131     {
 132         initProperties();
 133         return localResource.lastModified();
 134     }
 135
 136     public long getContentLength()
 137     {
 138         initProperties();
 139         return localResource.length();
 140     }
 141
 142     public void spool( OutputContext outputContext )
 143         throws IOException
 144     {
 145         if ( !isCollection() )
 146         {
 147             FileInputStream is = null;
 148             try
 149             {
 150                 outputContext.setContentLength( getContentLength() );
 151                 outputContext.setContentType( getContentType() );
 152
 153                 // Write content to stream
 154                 is = new FileInputStream( localResource );
 155                 IOUtils.copy( is, outputContext.getOutputStream() );
 156             }
 157             finally
 158             {
 159                 IOUtils.closeQuietly( is );
 160             }
 161         }
 162         else
 163         {
 164             IndexWriter writer = new IndexWriter( this, localResource, logicalResource );
 165             writer.write( outputContext );
 166         }
 167     }
 168
 169     public DavPropertyName[] getPropertyNames()
 170     {
 171         return getProperties().getPropertyNames();
 172     }
 173
 174     public DavProperty getProperty( DavPropertyName name )
 175     {
 176         initProperties();
 177         return properties.get( name );
 178     }
 179
 180     public DavPropertySet getProperties()
 181     {
 182         initProperties();
 183         return properties;
 184     }
 185
 186     public void setProperty( DavProperty property )
 187         throws DavException
 188     {
 189     }
 190
 191     public void removeProperty( DavPropertyName propertyName )
 192         throws DavException
 193     {
 194     }
 195
 196     public MultiStatusResponse alterProperties( DavPropertySet setProperties, DavPropertyNameSet removePropertyNames )
 197         throws DavException
 198     {
 199         return null;
 200     }
 201
 202     public MultiStatusResponse alterProperties( List changeList )
 203         throws DavException
 204     {
 205         return null;
 206     }
 207
 208     public DavResource getCollection()
 209     {
 210         DavResource parent = null;
 211         if ( getResourcePath() != null && !getResourcePath().equals( "/" ) )
 212         {
 213             String parentPath = Text.getRelativeParent( getResourcePath(), 1 );
 214             if ( parentPath.equals( "" ) )
 215             {
 216                 parentPath = "/";
 217             }
 218             DavResourceLocator parentloc = locator.getFactory().createResourceLocator( locator.getPrefix(), parentPath );
 219             try
 220             {
 221                 parent = factory.createResource( parentloc, null );
 222             }
 223             catch ( DavException e )
 224             {
 225                 // should not occur
 226             }
 227         }
 228         return parent;
 229     }
 230
 231     public void addMember( DavResource resource, InputContext inputContext )
 232         throws DavException
 233     {
 234         File localFile = new File( localResource, resource.getDisplayName() );
 235         if ( isCollection() && inputContext.hasStream() ) // New File
 236         {
 237             boolean deleteFile = false;
 238             FileOutputStream stream = null;
 239             try
 240             {
 241                 stream = new FileOutputStream( localFile );
 242                 IOUtils.copy( inputContext.getInputStream(), stream );
 243                 if ( inputContext.getContentLength() != localFile.length() )
 244                 {
 245                     deleteFile = true;
 246                     throw new DavException( HttpServletResponse.SC_BAD_REQUEST, "Content Header length was " +
 247                         inputContext.getContentLength() + " but was " + localFile.length() );
 248                 }
 249             }
 250             catch ( IOException e )
 251             {
 252                 throw new DavException( HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e );
 253             }
 254             finally
 255             {
 256                 IOUtils.closeQuietly( stream );
 257                 if ( deleteFile )
 258                 {
 259                     FileUtils.deleteQuietly( localFile );
 260                 }
 261             }
 262         }
 263         else if ( !inputContext.hasStream() && isCollection() ) // New directory
 264         {
 265             localFile.mkdir();
 266         }
 267         else
 268         {
 269             throw new DavException( HttpServletResponse.SC_BAD_REQUEST, "Could not write member " +
 270                 resource.getResourcePath() + " at " + getResourcePath() );
 271         }
 272     }
 273
 274     public DavResourceIterator getMembers()
 275     {
 276         ArrayList list = new ArrayList();
 277         if ( exists() && isCollection() )
 278         {
 279             for ( String item : localResource.list() )
 280             {
 281                 try
 282                 {
 283                     if ( !item.startsWith( HIDDEN_PATH_PREFIX ) )
 284                     {
 285                         String path = locator.getResourcePath() + '/' + item;
 286                         DavResourceLocator resourceLocator =
 287                             locator.getFactory().createResourceLocator( locator.getPrefix(), path );
 288                         DavResource resource = factory.createResource( resourceLocator, null );
 289                         if ( resource != null )
 290                             list.add( resource );
 291                     }
 292                 }
 293                 catch ( DavException e )
 294                 {
 295                     // Should not occur
 296                 }
 297             }
 298         }
 299         return new DavResourceIteratorImpl( list );
 300     }
 301
 302     public void removeMember( DavResource member )
 303         throws DavException
 304     {
 305         File localResource = checkDavResourceIsArchivaDavResource( member ).getLocalResource();
 306
 307         if ( !localResource.exists() )
 308         {
 309             throw new DavException( HttpServletResponse.SC_NOT_FOUND, member.getResourcePath() );
 310         }
 311
 312         boolean suceeded = false;
 313
 314         if ( localResource.isDirectory() )
 315         {
 316             try
 317             {
 318                 FileUtils.deleteDirectory( localResource );
 319                 suceeded = true;
 320             }
 321             catch ( IOException e )
 322             {
 323                 throw new DavException( HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e );
 324             }
 325         }
 326
 327         if ( !suceeded && localResource.isFile() )
 328         {
 329             suceeded = localResource.delete();
 330         }
 331
 332         if ( !suceeded )
 333         {
 334             throw new DavException( HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "Could not delete resource " +
 335                 member.getResourcePath() );
 336         }
 337     }
 338
 339     public void move( DavResource destination )
 340         throws DavException
 341     {
 342         if ( !exists() )
 343         {
 344             throw new DavException( HttpServletResponse.SC_NOT_FOUND, "Resource to copy does not exist." );
 345         }
 346
 347         try
 348         {
 349             ArchivaDavResource localResource = checkDavResourceIsArchivaDavResource( destination );
 350             if ( isCollection() )
 351             {
 352                 FileUtils.moveDirectory( getLocalResource(), localResource.getLocalResource() );
 353             }
 354             else
 355             {
 356                 FileUtils.moveFile( getLocalResource(), localResource.getLocalResource() );
 357             }
 358         }
 359         catch ( IOException e )
 360         {
 361             throw new DavException( HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e );
 362         }
 363     }
 364
 365     public void copy( DavResource destination, boolean shallow )
 366         throws DavException
 367     {
 368         if ( !exists() )
 369         {
 370             throw new DavException( HttpServletResponse.SC_NOT_FOUND, "Resource to copy does not exist." );
 371         }
 372
 373         if ( shallow && isCollection() )
 374         {
 375             throw new DavException( DavServletResponse.SC_FORBIDDEN, "Unable to perform shallow copy for collection" );
 376         }
 377
 378         try
 379         {
 380             ArchivaDavResource localResource = checkDavResourceIsArchivaDavResource( destination );
 381             if ( isCollection() )
 382             {
 383                 FileUtils.copyDirectory( getLocalResource(), localResource.getLocalResource() );
 384             }
 385             else
 386             {
 387                 FileUtils.copyFile( getLocalResource(), localResource.getLocalResource() );
 388             }
 389         }
 390         catch ( IOException e )
 391         {
 392             throw new DavException( HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e );
 393         }
 394     }
 395
 396     public boolean isLockable( Type type, Scope scope )
 397     {
 398         return false;
 399     }
 400
 401     public boolean hasLock( Type type, Scope scope )
 402     {
 403         return false;
 404     }
 405
 406     public ActiveLock getLock( Type type, Scope scope )
 407     {
 408         return null;
 409     }
 410
 411     public ActiveLock[] getLocks()
 412     {
 413         return new ActiveLock[0];
 414     }
 415
 416     public ActiveLock lock( LockInfo reqLockInfo )
 417         throws DavException
 418     {
 419         return null;
 420     }
 421
 422     public ActiveLock refreshLock( LockInfo reqLockInfo, String lockToken )
 423         throws DavException
 424     {
 425         return null;
 426     }
 427
 428     public void unlock( String lockToken )
 429         throws DavException
 430     {
 431     }
 432
 433     public void addLockManager( LockManager lockmgr )
 434     {
 435     }
 436
 437     public DavResourceFactory getFactory()
 438     {
 439         return factory;
 440     }
 441
 442     public DavSession getSession()
 443     {
 444         return null;
 445     }
 446
 447     /**
 448      * Fill the set of properties
 449      */
 450     protected void initProperties()
 451     {
 452         if ( !exists() || propsInitialized )
 453         {
 454             return;
 455         }
 456
 457         // set (or reset) fundamental properties
 458         if ( getDisplayName() != null )
 459         {
 460             properties.add( new DefaultDavProperty( DavPropertyName.DISPLAYNAME, getDisplayName() ) );
 461         }
 462         if ( isCollection() )
 463         {
 464             properties.add( new ResourceType( ResourceType.COLLECTION ) );
 465             // Windows XP support
 466             properties.add( new DefaultDavProperty( DavPropertyName.ISCOLLECTION, "1" ) );
 467         }
 468         else
 469         {
 470             properties.add( new ResourceType( ResourceType.DEFAULT_RESOURCE ) );
 471
 472             // Windows XP support
 473             properties.add( new DefaultDavProperty( DavPropertyName.ISCOLLECTION, "0" ) );
 474         }
 475
 476         // Need to get the ISO8601 date for properties
 477         DateTime dt = new DateTime( localResource.lastModified() );
 478         DateTimeFormatter fmt = ISODateTimeFormat.dateTime();
 479         String modifiedDate = fmt.print( dt );
 480
 481         properties.add( new DefaultDavProperty( DavPropertyName.GETLASTMODIFIED, modifiedDate ) );
 482
 483         properties.add( new DefaultDavProperty( DavPropertyName.CREATIONDATE, modifiedDate ) );
 484
 485         properties.add( new DefaultDavProperty( DavPropertyName.GETCONTENTLENGTH, localResource.length() ) );
 486
 487         propsInitialized = true;
 488     }
 489
 490     private ArchivaDavResource checkDavResourceIsArchivaDavResource( DavResource resource )
 491         throws DavException
 492     {
 493         if ( !( resource instanceof ArchivaDavResource ) )
 494         {
 495             throw new DavException( HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
 496                                     "DavResource is not instance of ArchivaDavResource" );
 497         }
 498         return (ArchivaDavResource) resource;
 499     }
 500 }