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

   1 package org.apache.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.archiva.admin.model.RepositoryAdminException;
  23 import org.apache.archiva.admin.model.beans.RemoteRepository;
  24 import org.apache.archiva.admin.model.remote.RemoteRepositoryAdmin;
  25 import org.apache.archiva.audit.AuditEvent;
  26 import org.apache.archiva.audit.AuditListener;
  27 import org.apache.archiva.audit.Auditable;
  28 import org.apache.archiva.common.plexusbridge.PlexusSisuBridge;
  29 import org.apache.archiva.common.plexusbridge.PlexusSisuBridgeException;
  30 import org.apache.archiva.common.utils.PathUtil;
  31 import org.apache.archiva.common.utils.VersionUtil;
  32 import org.apache.archiva.configuration.ArchivaConfiguration;
  33 import org.apache.archiva.configuration.RepositoryGroupConfiguration;
  34 import org.apache.archiva.indexer.merger.IndexMerger;
  35 import org.apache.archiva.indexer.merger.IndexMergerException;
  36 import org.apache.archiva.indexer.merger.TemporaryGroupIndex;
  37 import org.apache.archiva.indexer.search.RepositorySearch;
  38 import org.apache.archiva.maven2.metadata.MavenMetadataReader;
  39 import org.apache.archiva.metadata.repository.storage.RepositoryStorage;
  40 import org.apache.archiva.model.ArchivaRepositoryMetadata;
  41 import org.apache.archiva.model.ArtifactReference;
  42 import org.apache.archiva.policies.ProxyDownloadException;
  43 import org.apache.archiva.proxy.model.RepositoryProxyConnectors;
  44 import org.apache.archiva.redback.authentication.AuthenticationException;
  45 import org.apache.archiva.redback.authentication.AuthenticationResult;
  46 import org.apache.archiva.redback.authorization.AuthorizationException;
  47 import org.apache.archiva.redback.authorization.UnauthorizedException;
  48 import org.apache.archiva.redback.integration.filter.authentication.HttpAuthenticator;
  49 import org.apache.archiva.redback.policy.AccountLockedException;
  50 import org.apache.archiva.redback.policy.MustChangePasswordException;
  51 import org.apache.archiva.redback.system.SecuritySession;
  52 import org.apache.archiva.redback.users.User;
  53 import org.apache.archiva.redback.users.UserManager;
  54 import org.apache.archiva.repository.ManagedRepositoryContent;
  55 import org.apache.archiva.repository.RepositoryContentFactory;
  56 import org.apache.archiva.repository.RepositoryException;
  57 import org.apache.archiva.repository.RepositoryNotFoundException;
  58 import org.apache.archiva.repository.content.legacy.LegacyPathParser;
  59 import org.apache.archiva.repository.content.maven2.RepositoryRequest;
  60 import org.apache.archiva.repository.layout.LayoutException;
  61 import org.apache.archiva.repository.metadata.MetadataTools;
  62 import org.apache.archiva.repository.metadata.RepositoryMetadataException;
  63 import org.apache.archiva.repository.metadata.RepositoryMetadataMerge;
  64 import org.apache.archiva.repository.metadata.RepositoryMetadataWriter;
  65 import org.apache.archiva.scheduler.repository.model.RepositoryArchivaTaskScheduler;
  66 import org.apache.archiva.security.ServletAuthenticator;
  67 import org.apache.archiva.webdav.util.MimeTypes;
  68 import org.apache.archiva.webdav.util.RepositoryPathUtil;
  69 import org.apache.archiva.webdav.util.TemporaryGroupIndexSessionCleaner;
  70 import org.apache.archiva.webdav.util.WebdavMethodUtil;
  71 import org.apache.archiva.xml.XMLException;
  72 import org.apache.commons.io.FileUtils;
  73 import org.apache.commons.io.FilenameUtils;
  74 import org.apache.commons.lang.StringUtils;
  75 import org.apache.jackrabbit.webdav.DavException;
  76 import org.apache.jackrabbit.webdav.DavResource;
  77 import org.apache.jackrabbit.webdav.DavResourceFactory;
  78 import org.apache.jackrabbit.webdav.DavResourceLocator;
  79 import org.apache.jackrabbit.webdav.DavServletRequest;
  80 import org.apache.jackrabbit.webdav.DavServletResponse;
  81 import org.apache.jackrabbit.webdav.DavSession;
  82 import org.apache.jackrabbit.webdav.lock.LockManager;
  83 import org.apache.jackrabbit.webdav.lock.SimpleLockManager;
  84 import org.apache.maven.index.context.IndexingContext;
  85 import org.apache.maven.model.io.xpp3.MavenXpp3Reader;
  86 import org.codehaus.plexus.digest.ChecksumFile;
  87 import org.codehaus.plexus.digest.Digester;
  88 import org.codehaus.plexus.digest.DigesterException;
  89 import org.slf4j.Logger;
  90 import org.slf4j.LoggerFactory;
  91 import org.springframework.context.ApplicationContext;
  92 import org.springframework.stereotype.Service;
  93
  94 import javax.annotation.PostConstruct;
  95 import javax.inject.Inject;
  96 import javax.inject.Named;
  97 import javax.servlet.http.HttpServletResponse;
  98 import javax.servlet.http.HttpSession;
  99 import java.io.File;
 100 import java.io.IOException;
 101 import java.util.ArrayList;
 102 import java.util.Date;
 103 import java.util.HashMap;
 104 import java.util.HashSet;
 105 import java.util.List;
 106 import java.util.Map;
 107 import java.util.Set;
 108
 109 /**
 110  *
 111  */
 112 @Service ("davResourceFactory#archiva")
 113 public class ArchivaDavResourceFactory
 114     implements DavResourceFactory, Auditable
 115 {
 116     private static final String PROXIED_SUFFIX = " (proxied)";
 117
 118     private static final String HTTP_PUT_METHOD = "PUT";
 119
 120     private static final MavenXpp3Reader MAVEN_XPP_3_READER = new MavenXpp3Reader();
 121
 122     private Logger log = LoggerFactory.getLogger( ArchivaDavResourceFactory.class );
 123
 124     /**
 125      *
 126      */
 127     @Inject
 128     private List<AuditListener> auditListeners = new ArrayList<AuditListener>();
 129
 130     /**
 131      *
 132      */
 133     @Inject
 134     private RepositoryContentFactory repositoryFactory;
 135
 136     /**
 137      *
 138      */
 139     private RepositoryRequest repositoryRequest;
 140
 141     /**
 142      *
 143      */
 144     @Inject
 145     @Named (value = "repositoryProxyConnectors#default")
 146     private RepositoryProxyConnectors connectors;
 147
 148     /**
 149      *
 150      */
 151     @Inject
 152     private MetadataTools metadataTools;
 153
 154     /**
 155      *
 156      */
 157     @Inject
 158     private MimeTypes mimeTypes;
 159
 160     /**
 161      *
 162      */
 163     private ArchivaConfiguration archivaConfiguration;
 164
 165     /**
 166      *
 167      */
 168     @Inject
 169     private ServletAuthenticator servletAuth;
 170
 171     /**
 172      *
 173      */
 174     @Inject
 175     @Named (value = "httpAuthenticator#basic")
 176     private HttpAuthenticator httpAuth;
 177
 178     @Inject
 179     private RemoteRepositoryAdmin remoteRepositoryAdmin;
 180
 181     @Inject
 182     private IndexMerger indexMerger;
 183
 184     @Inject
 185     private RepositorySearch repositorySearch;
 186
 187     /**
 188      * Lock Manager - use simple implementation from JackRabbit
 189      */
 190     private final LockManager lockManager = new SimpleLockManager();
 191
 192     /**
 193      *
 194      */
 195     private ChecksumFile checksum;
 196
 197     /**
 198      *
 199      */
 200     private Digester digestSha1;
 201
 202     /**
 203      *
 204      */
 205     private Digester digestMd5;
 206
 207     /**
 208      *
 209      */
 210     @Inject
 211     @Named (value = "archivaTaskScheduler#repository")
 212     private RepositoryArchivaTaskScheduler scheduler;
 213
 214     private ApplicationContext applicationContext;
 215
 216     @Inject
 217     public ArchivaDavResourceFactory( ApplicationContext applicationContext, PlexusSisuBridge plexusSisuBridge,
 218                                       ArchivaConfiguration archivaConfiguration )
 219         throws PlexusSisuBridgeException
 220     {
 221         this.archivaConfiguration = archivaConfiguration;
 222         this.applicationContext = applicationContext;
 223         this.checksum = plexusSisuBridge.lookup( ChecksumFile.class );
 224
 225         this.digestMd5 = plexusSisuBridge.lookup( Digester.class, "md5" );
 226         this.digestSha1 = plexusSisuBridge.lookup( Digester.class, "sha1" );
 227
 228         // TODO remove this hard dependency on maven !!
 229         repositoryRequest = new RepositoryRequest( new LegacyPathParser( archivaConfiguration ) );
 230     }
 231
 232     @PostConstruct
 233     public void initialize()
 234     {
 235
 236     }
 237
 238     public DavResource createResource( final DavResourceLocator locator, final DavServletRequest request,
 239                                        final DavServletResponse response )
 240         throws DavException
 241     {
 242         ArchivaDavResourceLocator archivaLocator = checkLocatorIsInstanceOfRepositoryLocator( locator );
 243
 244         RepositoryGroupConfiguration repoGroupConfig =
 245             archivaConfiguration.getConfiguration().getRepositoryGroupsAsMap().get( archivaLocator.getRepositoryId() );
 246
 247         String activePrincipal = getActivePrincipal( request );
 248
 249         List<String> resourcesInAbsolutePath = new ArrayList<String>();
 250
 251         boolean readMethod = WebdavMethodUtil.isReadMethod( request.getMethod() );
 252         DavResource resource;
 253         if ( repoGroupConfig != null )
 254         {
 255             if ( !readMethod )
 256             {
 257                 throw new DavException( HttpServletResponse.SC_METHOD_NOT_ALLOWED,
 258                                         "Write method not allowed for repository groups." );
 259             }
 260
 261             log.debug( "Repository group '{}' accessed by '{}", repoGroupConfig.getId(), activePrincipal );
 262
 263             // handle browse requests for virtual repos
 264             if ( RepositoryPathUtil.getLogicalResource( archivaLocator.getOrigResourcePath() ).endsWith( "/" ) )
 265             {
 266                 return getResource( request, repoGroupConfig.getRepositories(), archivaLocator,
 267                                     archivaLocator.getRepositoryId() );
 268             }
 269             else
 270             {
 271                 // make a copy to avoid potential concurrent modifications (eg. by configuration)
 272                 // TODO: ultimately, locking might be more efficient than copying in this fashion since updates are
 273                 //  infrequent
 274                 List<String> repositories = new ArrayList<String>( repoGroupConfig.getRepositories() );
 275                 resource = processRepositoryGroup( request, archivaLocator, repositories, activePrincipal,
 276                                                    resourcesInAbsolutePath, archivaLocator.getRepositoryId() );
 277             }
 278         }
 279         else
 280         {
 281
 282             try
 283             {
 284                 RemoteRepository remoteRepository =
 285                     remoteRepositoryAdmin.getRemoteRepository( archivaLocator.getRepositoryId() );
 286
 287                 if ( remoteRepository != null )
 288                 {
 289                     String logicalResource = RepositoryPathUtil.getLogicalResource( locator.getResourcePath() );
 290                     IndexingContext indexingContext = remoteRepositoryAdmin.createIndexContext( remoteRepository );
 291                     File resourceFile = StringUtils.equals( logicalResource, "/" )
 292                         ? new File( indexingContext.getIndexDirectoryFile().getParent() )
 293                         : new File( indexingContext.getIndexDirectoryFile().getParent(), logicalResource );
 294                     resource = new ArchivaDavResource( resourceFile.getAbsolutePath(), locator.getResourcePath(), null,
 295                                                        request.getRemoteAddr(), activePrincipal,
 296                                                        request.getDavSession(), archivaLocator, this, mimeTypes,
 297                                                        auditListeners, scheduler );
 298                     setHeaders( response, locator, resource );
 299                     return resource;
 300                 }
 301             }
 302             catch ( RepositoryAdminException e )
 303             {
 304                 log.debug( "RepositoryException remote repository with d'{}' not found, msg: {}",
 305                            archivaLocator.getRepositoryId(), e.getMessage() );
 306             }
 307
 308             ManagedRepositoryContent managedRepository = null;
 309
 310             try
 311             {
 312                 managedRepository = repositoryFactory.getManagedRepositoryContent( archivaLocator.getRepositoryId() );
 313             }
 314             catch ( RepositoryNotFoundException e )
 315             {
 316                 throw new DavException( HttpServletResponse.SC_NOT_FOUND,
 317                                         "Invalid repository: " + archivaLocator.getRepositoryId() );
 318             }
 319             catch ( RepositoryException e )
 320             {
 321                 throw new DavException( HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e );
 322             }
 323
 324             log.debug( "Managed repository '{}' accessed by '{}'", managedRepository.getId(), activePrincipal );
 325
 326             resource = processRepository( request, archivaLocator, activePrincipal, managedRepository );
 327
 328             String logicalResource = RepositoryPathUtil.getLogicalResource( locator.getResourcePath() );
 329             resourcesInAbsolutePath.add(
 330                 new File( managedRepository.getRepoRoot(), logicalResource ).getAbsolutePath() );
 331         }
 332
 333         String requestedResource = request.getRequestURI();
 334
 335         // MRM-872 : merge all available metadata
 336         // merge metadata only when requested via the repo group
 337         if ( ( repositoryRequest.isMetadata( requestedResource ) || repositoryRequest.isMetadataSupportFile(
 338             requestedResource ) ) && repoGroupConfig != null )
 339         {
 340             // this should only be at the project level not version level!
 341             if ( isProjectReference( requestedResource ) )
 342             {
 343
 344                 ArchivaDavResource res = (ArchivaDavResource) resource;
 345                 String filePath =
 346                     StringUtils.substringBeforeLast( res.getLocalResource().getAbsolutePath().replace( '\\', '/' ),
 347                                                      "/" );
 348                 filePath = filePath + "/maven-metadata-" + repoGroupConfig.getId() + ".xml";
 349
 350                 // for MRM-872 handle checksums of the merged metadata files
 351                 if ( repositoryRequest.isSupportFile( requestedResource ) )
 352                 {
 353                     File metadataChecksum =
 354                         new File( filePath + "." + StringUtils.substringAfterLast( requestedResource, "." ) );
 355                     if ( metadataChecksum.exists() )
 356                     {
 357                         LogicalResource logicalResource =
 358                             new LogicalResource( RepositoryPathUtil.getLogicalResource( locator.getResourcePath() ) );
 359
 360                         resource =
 361                             new ArchivaDavResource( metadataChecksum.getAbsolutePath(), logicalResource.getPath(), null,
 362                                                     request.getRemoteAddr(), activePrincipal, request.getDavSession(),
 363                                                     archivaLocator, this, mimeTypes, auditListeners, scheduler );
 364                     }
 365                 }
 366                 else
 367                 {
 368                     if ( resourcesInAbsolutePath != null && resourcesInAbsolutePath.size() > 1 )
 369                     {
 370                         // merge the metadata of all repos under group
 371                         ArchivaRepositoryMetadata mergedMetadata = new ArchivaRepositoryMetadata();
 372                         for ( String resourceAbsPath : resourcesInAbsolutePath )
 373                         {
 374                             try
 375                             {
 376                                 File metadataFile = new File( resourceAbsPath );
 377                                 ArchivaRepositoryMetadata repoMetadata = MavenMetadataReader.read( metadataFile );
 378                                 mergedMetadata = RepositoryMetadataMerge.merge( mergedMetadata, repoMetadata );
 379                             }
 380                             catch ( XMLException e )
 381                             {
 382                                 throw new DavException( HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
 383                                                         "Error occurred while reading metadata file." );
 384                             }
 385                             catch ( RepositoryMetadataException r )
 386                             {
 387                                 throw new DavException( HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
 388                                                         "Error occurred while merging metadata file." );
 389                             }
 390                         }
 391
 392                         try
 393                         {
 394                             File resourceFile = writeMergedMetadataToFile( mergedMetadata, filePath );
 395
 396                             LogicalResource logicalResource = new LogicalResource(
 397                                 RepositoryPathUtil.getLogicalResource( locator.getResourcePath() ) );
 398
 399                             resource =
 400                                 new ArchivaDavResource( resourceFile.getAbsolutePath(), logicalResource.getPath(), null,
 401                                                         request.getRemoteAddr(), activePrincipal,
 402                                                         request.getDavSession(), archivaLocator, this, mimeTypes,
 403                                                         auditListeners, scheduler );
 404                         }
 405                         catch ( RepositoryMetadataException r )
 406                         {
 407                             throw new DavException( HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
 408                                                     "Error occurred while writing metadata file." );
 409                         }
 410                         catch ( IOException ie )
 411                         {
 412                             throw new DavException( HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
 413                                                     "Error occurred while generating checksum files." );
 414                         }
 415                         catch ( DigesterException de )
 416                         {
 417                             throw new DavException( HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
 418                                                     "Error occurred while generating checksum files." );
 419                         }
 420                     }
 421                 }
 422             }
 423         }
 424
 425         setHeaders( response, locator, resource );
 426
 427         // compatibility with MRM-440 to ensure browsing the repository works ok
 428         if ( resource.isCollection() && !request.getRequestURI().endsWith( "/" ) )
 429         {
 430             throw new BrowserRedirectException( resource.getHref() );
 431         }
 432         resource.addLockManager( lockManager );
 433         return resource;
 434     }
 435
 436     private DavResource processRepositoryGroup( final DavServletRequest request,
 437                                                 ArchivaDavResourceLocator archivaLocator, List<String> repositories,
 438                                                 String activePrincipal, List<String> resourcesInAbsolutePath,
 439                                                 String repositoryGroupId )
 440         throws DavException
 441     {
 442         DavResource resource = null;
 443         List<DavException> storedExceptions = new ArrayList<DavException>();
 444
 445         String pathInfo = StringUtils.removeEnd( request.getPathInfo(), "/" );
 446
 447         String rootPath = StringUtils.substringBeforeLast( pathInfo, "/" );
 448
 449         if ( StringUtils.endsWith( rootPath, "/.indexer" ) )
 450         {
 451             // we are in the case of index file request
 452             String requestedFileName = StringUtils.substringAfterLast( pathInfo, "/" );
 453             File temporaryIndexDirectory =
 454                 buildMergedIndexDirectory( repositories, activePrincipal, request, repositoryGroupId );
 455
 456             File resourceFile = new File( temporaryIndexDirectory, requestedFileName );
 457             resource = new ArchivaDavResource( resourceFile.getAbsolutePath(), requestedFileName, null,
 458                                                request.getRemoteAddr(), activePrincipal, request.getDavSession(),
 459                                                archivaLocator, this, mimeTypes, auditListeners, scheduler );
 460
 461         }
 462         else
 463         {
 464             for ( String repositoryId : repositories )
 465             {
 466                 ManagedRepositoryContent managedRepository;
 467                 try
 468                 {
 469                     managedRepository = repositoryFactory.getManagedRepositoryContent( repositoryId );
 470                 }
 471                 catch ( RepositoryNotFoundException e )
 472                 {
 473                     throw new DavException( HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e );
 474                 }
 475                 catch ( RepositoryException e )
 476                 {
 477                     throw new DavException( HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e );
 478                 }
 479
 480                 try
 481                 {
 482                     DavResource updatedResource =
 483                         processRepository( request, archivaLocator, activePrincipal, managedRepository );
 484                     if ( resource == null )
 485                     {
 486                         resource = updatedResource;
 487                     }
 488
 489                     String logicalResource = RepositoryPathUtil.getLogicalResource( archivaLocator.getResourcePath() );
 490                     if ( logicalResource.endsWith( "/" ) )
 491                     {
 492                         logicalResource = logicalResource.substring( 1 );
 493                     }
 494                     resourcesInAbsolutePath.add(
 495                         new File( managedRepository.getRepoRoot(), logicalResource ).getAbsolutePath() );
 496                 }
 497                 catch ( DavException e )
 498                 {
 499                     storedExceptions.add( e );
 500                 }
 501             }
 502         }
 503         if ( resource == null )
 504         {
 505             if ( !storedExceptions.isEmpty() )
 506             {
 507                 // MRM-1232
 508                 for ( DavException e : storedExceptions )
 509                 {
 510                     if ( 401 == e.getErrorCode() )
 511                     {
 512                         throw e;
 513                     }
 514                 }
 515
 516                 throw new DavException( HttpServletResponse.SC_NOT_FOUND );
 517             }
 518             else
 519             {
 520                 throw new DavException( HttpServletResponse.SC_NOT_FOUND );
 521             }
 522         }
 523         return resource;
 524     }
 525
 526     private DavResource processRepository( final DavServletRequest request, ArchivaDavResourceLocator archivaLocator,
 527                                            String activePrincipal, ManagedRepositoryContent managedRepository )
 528         throws DavException
 529     {
 530         DavResource resource = null;
 531         if ( isAuthorized( request, managedRepository.getId() ) )
 532         {
 533             String path = RepositoryPathUtil.getLogicalResource( archivaLocator.getResourcePath() );
 534             if ( path.startsWith( "/" ) )
 535             {
 536                 path = path.substring( 1 );
 537             }
 538             LogicalResource logicalResource = new LogicalResource( path );
 539             File resourceFile = new File( managedRepository.getRepoRoot(), path );
 540             resource = new ArchivaDavResource( resourceFile.getAbsolutePath(), path, managedRepository.getRepository(),
 541                                                request.getRemoteAddr(), activePrincipal, request.getDavSession(),
 542                                                archivaLocator, this, mimeTypes, auditListeners, scheduler );
 543
 544             if ( WebdavMethodUtil.isReadMethod( request.getMethod() ) )
 545             {
 546                 if ( archivaLocator.getHref( false ).endsWith( "/" ) && !resourceFile.isDirectory() )
 547                 {
 548                     // force a resource not found
 549                     throw new DavException( HttpServletResponse.SC_NOT_FOUND, "Resource does not exist" );
 550                 }
 551                 else
 552                 {
 553                     if ( !resource.isCollection() )
 554                     {
 555                         boolean previouslyExisted = resourceFile.exists();
 556
 557                         // Attempt to fetch the resource from any defined proxy.
 558                         boolean fromProxy = fetchContentFromProxies( managedRepository, request, logicalResource );
 559
 560                         // At this point the incoming request can either be in default or
 561                         // legacy layout format.
 562                         try
 563                         {
 564                             // Perform an adjustment of the resource to the managed
 565                             // repository expected path.
 566                             String localResourcePath =
 567                                 repositoryRequest.toNativePath( logicalResource.getPath(), managedRepository );
 568                             resourceFile = new File( managedRepository.getRepoRoot(), localResourcePath );
 569                             resource =
 570                                 new ArchivaDavResource( resourceFile.getAbsolutePath(), logicalResource.getPath(),
 571                                                         managedRepository.getRepository(), request.getRemoteAddr(),
 572                                                         activePrincipal, request.getDavSession(), archivaLocator, this,
 573                                                         mimeTypes, auditListeners, scheduler );
 574                         }
 575                         catch ( LayoutException e )
 576                         {
 577                             if ( !resourceFile.exists() )
 578                             {
 579                                 throw new DavException( HttpServletResponse.SC_NOT_FOUND, e );
 580                             }
 581                         }
 582
 583                         if ( fromProxy )
 584                         {
 585                             String event = ( previouslyExisted ? AuditEvent.MODIFY_FILE : AuditEvent.CREATE_FILE )
 586                                 + PROXIED_SUFFIX;
 587
 588                             log.debug( "Proxied artifact '{}' in repository '{}' (current user '{}')",
 589                                        resourceFile.getName(), managedRepository.getId(), activePrincipal );
 590
 591                             triggerAuditEvent( request.getRemoteAddr(), archivaLocator.getRepositoryId(),
 592                                                logicalResource.getPath(), event, activePrincipal );
 593                         }
 594
 595                         if ( !resourceFile.exists() )
 596                         {
 597                             throw new DavException( HttpServletResponse.SC_NOT_FOUND, "Resource does not exist" );
 598                         }
 599                     }
 600                 }
 601             }
 602
 603             if ( request.getMethod().equals( HTTP_PUT_METHOD ) )
 604             {
 605                 String resourcePath = logicalResource.getPath();
 606
 607                 // check if target repo is enabled for releases
 608                 // we suppose that release-artifacts can be deployed only to repos enabled for releases
 609                 if ( managedRepository.getRepository().isReleases() && !repositoryRequest.isMetadata( resourcePath )
 610                     && !repositoryRequest.isSupportFile( resourcePath ) )
 611                 {
 612                     ArtifactReference artifact = null;
 613                     try
 614                     {
 615                         artifact = managedRepository.toArtifactReference( resourcePath );
 616
 617                         if ( !VersionUtil.isSnapshot( artifact.getVersion() ) )
 618                         {
 619                             // check if artifact already exists and if artifact re-deployment to the repository is allowed
 620                             if ( managedRepository.hasContent( artifact )
 621                                 && managedRepository.getRepository().isBlockRedeployments() )
 622                             {
 623                                 log.warn( "Overwriting released artifacts in repository '{}' is not allowed.",
 624                                           managedRepository.getId() );
 625                                 throw new DavException( HttpServletResponse.SC_CONFLICT,
 626                                                         "Overwriting released artifacts is not allowed." );
 627                             }
 628                         }
 629                     }
 630                     catch ( LayoutException e )
 631                     {
 632                         log.warn( "Artifact path '" + resourcePath + "' is invalid." );
 633                     }
 634                 }
 635
 636                 /*
 637                  * Create parent directories that don't exist when writing a file This actually makes this
 638                  * implementation not compliant to the WebDAV RFC - but we have enough knowledge about how the
 639                  * collection is being used to do this reasonably and some versions of Maven's WebDAV don't correctly
 640                  * create the collections themselves.
 641                  */
 642
 643                 File rootDirectory = new File( managedRepository.getRepoRoot() );
 644                 File destDir = new File( rootDirectory, logicalResource.getPath() ).getParentFile();
 645
 646                 if ( !destDir.exists() )
 647                 {
 648                     destDir.mkdirs();
 649                     String relPath = PathUtil.getRelative( rootDirectory.getAbsolutePath(), destDir );
 650
 651                     log.debug( "Creating destination directory '{}' (current user '{}')", destDir.getName(),
 652                                activePrincipal );
 653
 654                     triggerAuditEvent( request.getRemoteAddr(), managedRepository.getId(), relPath,
 655                                        AuditEvent.CREATE_DIR, activePrincipal );
 656                 }
 657             }
 658         }
 659         return resource;
 660     }
 661
 662     public DavResource createResource( final DavResourceLocator locator, final DavSession davSession )
 663         throws DavException
 664     {
 665         ArchivaDavResourceLocator archivaLocator = checkLocatorIsInstanceOfRepositoryLocator( locator );
 666
 667         ManagedRepositoryContent managedRepository;
 668         try
 669         {
 670             managedRepository = repositoryFactory.getManagedRepositoryContent( archivaLocator.getRepositoryId() );
 671         }
 672         catch ( RepositoryNotFoundException e )
 673         {
 674             throw new DavException( HttpServletResponse.SC_NOT_FOUND,
 675                                     "Invalid repository: " + archivaLocator.getRepositoryId() );
 676         }
 677         catch ( RepositoryException e )
 678         {
 679             throw new DavException( HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e );
 680         }
 681
 682         String logicalResource = RepositoryPathUtil.getLogicalResource( locator.getResourcePath() );
 683         if ( logicalResource.startsWith( "/" ) )
 684         {
 685             logicalResource = logicalResource.substring( 1 );
 686         }
 687         File resourceFile = new File( managedRepository.getRepoRoot(), logicalResource );
 688         DavResource resource =
 689             new ArchivaDavResource( resourceFile.getAbsolutePath(), logicalResource, managedRepository.getRepository(),
 690                                     davSession, archivaLocator, this, mimeTypes, auditListeners, scheduler );
 691
 692         resource.addLockManager( lockManager );
 693         return resource;
 694     }
 695
 696     private boolean fetchContentFromProxies( ManagedRepositoryContent managedRepository, DavServletRequest request,
 697                                              LogicalResource resource )
 698         throws DavException
 699     {
 700         String path = resource.getPath();
 701         if ( repositoryRequest.isSupportFile( path ) )
 702         {
 703             File proxiedFile = connectors.fetchFromProxies( managedRepository, path );
 704
 705             return ( proxiedFile != null );
 706         }
 707
 708         // Is it a Metadata resource?
 709         if ( repositoryRequest.isDefault( path ) && repositoryRequest.isMetadata( path ) )
 710         {
 711             return connectors.fetchMetatadaFromProxies( managedRepository, path ) != null;
 712         }
 713
 714         // Is it an Archetype Catalog?
 715         if ( repositoryRequest.isArchetypeCatalog( path ) )
 716         {
 717             // FIXME we must implement a merge of remote archetype catalog from remote servers.
 718             File proxiedFile = connectors.fetchFromProxies( managedRepository, path );
 719
 720             return ( proxiedFile != null );
 721         }
 722
 723         // Not any of the above? Then it's gotta be an artifact reference.
 724         try
 725         {
 726             // Get the artifact reference in a layout neutral way.
 727             ArtifactReference artifact = repositoryRequest.toArtifactReference( path );
 728
 729             if ( artifact != null )
 730             {
 731                 String repositoryLayout = managedRepository.getRepository().getLayout();
 732
 733                 RepositoryStorage repositoryStorage =
 734                     this.applicationContext.getBean( "repositoryStorage#" + repositoryLayout, RepositoryStorage.class );
 735                 repositoryStorage.applyServerSideRelocation( managedRepository, artifact );
 736
 737                 File proxiedFile = connectors.fetchFromProxies( managedRepository, artifact );
 738
 739                 resource.setPath( managedRepository.toPath( artifact ) );
 740
 741                 log.debug( "Proxied artifact '{}:{}:{}'", artifact.getGroupId(), artifact.getArtifactId(),
 742                            artifact.getVersion() );
 743
 744                 return ( proxiedFile != null );
 745             }
 746         }
 747         catch ( LayoutException e )
 748         {
 749             /* eat it */
 750         }
 751         catch ( ProxyDownloadException e )
 752         {
 753             log.error( e.getMessage(), e );
 754             throw new DavException( HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
 755                                     "Unable to fetch artifact resource." );
 756         }
 757         return false;
 758     }
 759
 760     // TODO: remove?
 761
 762     private void triggerAuditEvent( String remoteIP, String repositoryId, String resource, String action,
 763                                     String principal )
 764     {
 765         AuditEvent event = new AuditEvent( repositoryId, principal, resource, action );
 766         event.setRemoteIP( remoteIP );
 767
 768         for ( AuditListener listener : auditListeners )
 769         {
 770             listener.auditEvent( event );
 771         }
 772     }
 773
 774     public void addAuditListener( AuditListener listener )
 775     {
 776         this.auditListeners.add( listener );
 777     }
 778
 779     public void clearAuditListeners()
 780     {
 781         this.auditListeners.clear();
 782     }
 783
 784     public void removeAuditListener( AuditListener listener )
 785     {
 786         this.auditListeners.remove( listener );
 787     }
 788
 789     private void setHeaders( DavServletResponse response, DavResourceLocator locator, DavResource resource )
 790     {
 791         // [MRM-503] - Metadata file need Pragma:no-cache response
 792         // header.
 793         if ( locator.getResourcePath().endsWith( "/maven-metadata.xml" )
 794             || ( (ArchivaDavResource) resource ).getLocalResource().isDirectory() )
 795         {
 796             response.setHeader( "Pragma", "no-cache" );
 797             response.setHeader( "Cache-Control", "no-cache" );
 798             response.setDateHeader( "Last-Modified", new Date().getTime() );
 799         }
 800         // if the resource is a directory don't cache it as new groupId deployed will be available
 801         // without need of refreshing browser
 802         else
 803         {
 804             // We need to specify this so connecting wagons can work correctly
 805             response.setDateHeader( "Last-Modified", resource.getModificationTime() );
 806         }
 807         // TODO: [MRM-524] determine http caching options for other types of files (artifacts, sha1, md5, snapshots)
 808     }
 809
 810     private ArchivaDavResourceLocator checkLocatorIsInstanceOfRepositoryLocator( DavResourceLocator locator )
 811         throws DavException
 812     {
 813         if ( !( locator instanceof ArchivaDavResourceLocator ) )
 814         {
 815             throw new DavException( HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
 816                                     "Locator does not implement RepositoryLocator" );
 817         }
 818
 819         // Hidden paths
 820         if ( locator.getResourcePath().startsWith( ArchivaDavResource.HIDDEN_PATH_PREFIX ) )
 821         {
 822             throw new DavException( HttpServletResponse.SC_NOT_FOUND );
 823         }
 824
 825         ArchivaDavResourceLocator archivaLocator = (ArchivaDavResourceLocator) locator;
 826
 827         // MRM-419 - Windows Webdav support. Should not 404 if there is no content.
 828         if ( StringUtils.isEmpty( archivaLocator.getRepositoryId() ) )
 829         {
 830             throw new DavException( HttpServletResponse.SC_NO_CONTENT );
 831         }
 832         return archivaLocator;
 833     }
 834
 835     private static class LogicalResource
 836     {
 837         private String path;
 838
 839         public LogicalResource( String path )
 840         {
 841             this.path = path;
 842         }
 843
 844         public String getPath()
 845         {
 846             return path;
 847         }
 848
 849         public void setPath( String path )
 850         {
 851             this.path = path;
 852         }
 853     }
 854
 855     protected boolean isAuthorized( DavServletRequest request, String repositoryId )
 856         throws DavException
 857     {
 858         try
 859         {
 860             AuthenticationResult result = httpAuth.getAuthenticationResult( request, null );
 861             SecuritySession securitySession = httpAuth.getSecuritySession( request.getSession( true ) );
 862
 863             return servletAuth.isAuthenticated( request, result ) && servletAuth.isAuthorized( request, securitySession,
 864                                                                                                repositoryId,
 865                                                                                                WebdavMethodUtil.getMethodPermission(
 866                                                                                                    request.getMethod() ) );
 867         }
 868         catch ( AuthenticationException e )
 869         {
 870             // safety check for MRM-911
 871             String guest = UserManager.GUEST_USERNAME;
 872             try
 873             {
 874                 if ( servletAuth.isAuthorized( guest,
 875                                                ( (ArchivaDavResourceLocator) request.getRequestLocator() ).getRepositoryId(),
 876                                                WebdavMethodUtil.getMethodPermission( request.getMethod() ) ) )
 877                 {
 878                     return true;
 879                 }
 880             }
 881             catch ( UnauthorizedException ae )
 882             {
 883                 throw new UnauthorizedDavException( repositoryId,
 884                                                     "You are not authenticated and authorized to access any repository." );
 885             }
 886
 887             throw new UnauthorizedDavException( repositoryId, "You are not authenticated" );
 888         }
 889         catch ( MustChangePasswordException e )
 890         {
 891             throw new UnauthorizedDavException( repositoryId, "You must change your password." );
 892         }
 893         catch ( AccountLockedException e )
 894         {
 895             throw new UnauthorizedDavException( repositoryId, "User account is locked." );
 896         }
 897         catch ( AuthorizationException e )
 898         {
 899             throw new DavException( HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
 900                                     "Fatal Authorization Subsystem Error." );
 901         }
 902         catch ( UnauthorizedException e )
 903         {
 904             throw new UnauthorizedDavException( repositoryId, e.getMessage() );
 905         }
 906     }
 907
 908     private DavResource getResource( DavServletRequest request, List<String> repositories,
 909                                      ArchivaDavResourceLocator locator, String groupId )
 910         throws DavException
 911     {
 912         List<File> mergedRepositoryContents = new ArrayList<File>();
 913         String path = RepositoryPathUtil.getLogicalResource( locator.getResourcePath() );
 914         if ( path.startsWith( "/" ) )
 915         {
 916             path = path.substring( 1 );
 917         }
 918         LogicalResource logicalResource = new LogicalResource( path );
 919
 920         // flow:
 921         // if the current user logged in has permission to any of the repositories, allow user to
 922         // browse the repo group but displaying only the repositories which the user has permission to access.
 923         // otherwise, prompt for authentication.
 924
 925         String activePrincipal = getActivePrincipal( request );
 926
 927         boolean allow = isAllowedToContinue( request, repositories, activePrincipal );
 928
 929         if ( allow )
 930         {
 931
 932             // remove last /
 933             String pathInfo = StringUtils.removeEnd( request.getPathInfo(), "/" );
 934             if ( StringUtils.endsWith( pathInfo, "/.indexer" ) )
 935             {
 936                 File mergedRepoDir = buildMergedIndexDirectory( repositories, activePrincipal, request, groupId );
 937                 mergedRepositoryContents.add( mergedRepoDir );
 938             }
 939             else
 940             {
 941                 for ( String repository : repositories )
 942                 {
 943                     ManagedRepositoryContent managedRepository = null;
 944
 945                     try
 946                     {
 947                         managedRepository = repositoryFactory.getManagedRepositoryContent( repository );
 948                     }
 949                     catch ( RepositoryNotFoundException e )
 950                     {
 951                         throw new DavException( HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
 952                                                 "Invalid managed repository <" + repository + ">: " + e.getMessage() );
 953                     }
 954                     catch ( RepositoryException e )
 955                     {
 956                         throw new DavException( HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
 957                                                 "Invalid managed repository <" + repository + ">: " + e.getMessage() );
 958                     }
 959
 960                     File resourceFile = new File( managedRepository.getRepoRoot(), logicalResource.getPath() );
 961                     if ( resourceFile.exists() )
 962                     {
 963                         // in case of group displaying index directory doesn't have sense !!
 964                         String repoIndexDirectory = managedRepository.getRepository().getIndexDirectory();
 965                         if ( StringUtils.isNotEmpty( repoIndexDirectory ) )
 966                         {
 967                             if ( !new File( repoIndexDirectory ).isAbsolute() )
 968                             {
 969                                 repoIndexDirectory = new File( managedRepository.getRepository().getLocation(),
 970                                                                StringUtils.isEmpty( repoIndexDirectory )
 971                                                                    ? ".indexer"
 972                                                                    : repoIndexDirectory ).getAbsolutePath();
 973                             }
 974                         }
 975                         if ( StringUtils.isEmpty( repoIndexDirectory ) )
 976                         {
 977                             repoIndexDirectory = new File( managedRepository.getRepository().getLocation(),
 978                                                            ".indexer" ).getAbsolutePath();
 979                         }
 980
 981                         if ( !StringUtils.equals( FilenameUtils.normalize( repoIndexDirectory ),
 982                                                   FilenameUtils.normalize( resourceFile.getAbsolutePath() ) ) )
 983                         {
 984                             // for prompted authentication
 985                             if ( httpAuth.getSecuritySession( request.getSession( true ) ) != null )
 986                             {
 987                                 try
 988                                 {
 989                                     if ( isAuthorized( request, repository ) )
 990                                     {
 991                                         mergedRepositoryContents.add( resourceFile );
 992                                         log.debug( "Repository '{}' accessed by '{}'", repository, activePrincipal );
 993                                     }
 994                                 }
 995                                 catch ( DavException e )
 996                                 {
 997                                     // TODO: review exception handling
 998
 999                                     log.debug( "Skipping repository '{}' for user '{}': {}", managedRepository,
1000                                                activePrincipal, e.getMessage() );
1001
1002                                 }
1003
1004                             }
1005                             else
1006                             {
1007                                 // for the current user logged in
1008                                 try
1009                                 {
1010                                     if ( servletAuth.isAuthorized( activePrincipal, repository,
1011                                                                    WebdavMethodUtil.getMethodPermission(
1012                                                                        request.getMethod() ) ) )
1013                                     {
1014                                         mergedRepositoryContents.add( resourceFile );
1015                                         log.debug( "Repository '{}' accessed by '{}'", repository, activePrincipal );
1016                                     }
1017                                 }
1018                                 catch ( UnauthorizedException e )
1019                                 {
1020                                     // TODO: review exception handling
1021
1022                                     log.debug( "Skipping repository '{}' for user '{}': {}", managedRepository,
1023                                                activePrincipal, e.getMessage() );
1024
1025                                 }
1026                             }
1027                         }
1028                     }
1029                 }
1030             }
1031         }
1032         else
1033         {
1034             throw new UnauthorizedDavException( locator.getRepositoryId(), "User not authorized." );
1035         }
1036
1037         ArchivaVirtualDavResource resource =
1038             new ArchivaVirtualDavResource( mergedRepositoryContents, logicalResource.getPath(), mimeTypes, locator,
1039                                            this );
1040
1041         // compatibility with MRM-440 to ensure browsing the repository group works ok
1042         if ( resource.isCollection() && !request.getRequestURI().endsWith( "/" ) )
1043         {
1044             throw new BrowserRedirectException( resource.getHref() );
1045         }
1046
1047         return resource;
1048     }
1049
1050     protected String getActivePrincipal( DavServletRequest request )
1051     {
1052         User sessionUser = httpAuth.getSessionUser( request.getSession() );
1053         return sessionUser != null ? sessionUser.getUsername() : UserManager.GUEST_USERNAME;
1054     }
1055
1056     /**
1057      * Check if the current user is authorized to access any of the repos
1058      *
1059      * @param request
1060      * @param repositories
1061      * @param activePrincipal
1062      * @return
1063      */
1064     private boolean isAllowedToContinue( DavServletRequest request, List<String> repositories, String activePrincipal )
1065     {
1066         // when no repositories configured it's impossible to browse nothing !
1067         // at least make possible to see nothing :-)
1068         if ( repositories == null || repositories.isEmpty() )
1069         {
1070             return true;
1071         }
1072
1073         boolean allow = false;
1074
1075         // if securitySession != null, it means that the user was prompted for authentication
1076         if ( httpAuth.getSecuritySession( request.getSession() ) != null )
1077         {
1078             for ( String repository : repositories )
1079             {
1080                 try
1081                 {
1082                     if ( isAuthorized( request, repository ) )
1083                     {
1084                         allow = true;
1085                         break;
1086                     }
1087                 }
1088                 catch ( DavException e )
1089                 {
1090                     continue;
1091                 }
1092             }
1093         }
1094         else
1095         {
1096             for ( String repository : repositories )
1097             {
1098                 try
1099                 {
1100                     if ( servletAuth.isAuthorized( activePrincipal, repository,
1101                                                    WebdavMethodUtil.getMethodPermission( request.getMethod() ) ) )
1102                     {
1103                         allow = true;
1104                         break;
1105                     }
1106                 }
1107                 catch ( UnauthorizedException e )
1108                 {
1109                     continue;
1110                 }
1111             }
1112         }
1113
1114         return allow;
1115     }
1116
1117     private File writeMergedMetadataToFile( ArchivaRepositoryMetadata mergedMetadata, String outputFilename )
1118         throws RepositoryMetadataException, DigesterException, IOException
1119     {
1120         File outputFile = new File( outputFilename );
1121         if ( outputFile.exists() )
1122         {
1123             FileUtils.deleteQuietly( outputFile );
1124         }
1125
1126         outputFile.getParentFile().mkdirs();
1127         RepositoryMetadataWriter.write( mergedMetadata, outputFile );
1128
1129         createChecksumFile( outputFilename, digestSha1 );
1130         createChecksumFile( outputFilename, digestMd5 );
1131
1132         return outputFile;
1133     }
1134
1135     private void createChecksumFile( String path, Digester digester )
1136         throws DigesterException, IOException
1137     {
1138         File checksumFile = new File( path + digester.getFilenameExtension() );
1139         if ( !checksumFile.exists() )
1140         {
1141             FileUtils.deleteQuietly( checksumFile );
1142             checksum.createChecksum( new File( path ), digester );
1143         }
1144         else if ( !checksumFile.isFile() )
1145         {
1146             log.error( "Checksum file is not a file." );
1147         }
1148     }
1149
1150     private boolean isProjectReference( String requestedResource )
1151     {
1152         try
1153         {
1154             metadataTools.toVersionedReference( requestedResource );
1155             return false;
1156         }
1157         catch ( RepositoryMetadataException re )
1158         {
1159             return true;
1160         }
1161     }
1162
1163     protected File buildMergedIndexDirectory( List<String> repositories, String activePrincipal,
1164                                               DavServletRequest request, String groupId )
1165         throws DavException
1166     {
1167
1168         try
1169         {
1170             HttpSession session = request.getSession();
1171
1172             Map<String, TemporaryGroupIndex> temporaryGroupIndexMap =
1173                 (Map<String, TemporaryGroupIndex>) session.getAttribute(
1174                     TemporaryGroupIndexSessionCleaner.TEMPORARY_INDEX_SESSION_KEY );
1175             if ( temporaryGroupIndexMap == null )
1176             {
1177                 temporaryGroupIndexMap = new HashMap<String, TemporaryGroupIndex>();
1178             }
1179
1180             TemporaryGroupIndex tmp = temporaryGroupIndexMap.get( groupId );
1181
1182             if ( tmp != null && tmp.getDirectory() != null && tmp.getDirectory().exists() )
1183             {
1184                 if ( System.currentTimeMillis() - tmp.getCreationTime() > ( indexMerger.getDefaultGroupIndexTtl() * 60
1185                     * 1000 ) )
1186                 {
1187                     log.debug( "tmp group index is too old so delete it" );
1188                     indexMerger.cleanTemporaryGroupIndex( tmp );
1189                 }
1190                 else
1191                 {
1192                     return tmp.getDirectory();
1193                 }
1194             }
1195
1196             Set<String> authzRepos = new HashSet<String>();
1197             for ( String repository : repositories )
1198             {
1199                 try
1200                 {
1201                     if ( servletAuth.isAuthorized( activePrincipal, repository,
1202                                                    WebdavMethodUtil.getMethodPermission( request.getMethod() ) ) )
1203                     {
1204                         authzRepos.add( repository );
1205                         authzRepos.addAll( this.repositorySearch.getRemoteIndexingContextIds( repository ) );
1206                     }
1207                 }
1208                 catch ( UnauthorizedException e )
1209                 {
1210                     // TODO: review exception handling
1211
1212                     log.debug( "Skipping repository '{}' for user '{}': {}", repository, activePrincipal,
1213                                e.getMessage() );
1214                 }
1215             }
1216             log.info( "generate temporary merged index for repository group '{}' for repositories '{}'", groupId,
1217                       authzRepos );
1218             IndexingContext indexingContext = indexMerger.buildMergedIndex( authzRepos, true );
1219             File mergedRepoDir = indexingContext.getIndexDirectoryFile();
1220             TemporaryGroupIndex temporaryGroupIndex =
1221                 new TemporaryGroupIndex( mergedRepoDir, indexingContext.getId() ).setCreationTime(
1222                     new Date().getTime() );
1223             temporaryGroupIndexMap.put( groupId, temporaryGroupIndex );
1224             session.setAttribute( TemporaryGroupIndexSessionCleaner.TEMPORARY_INDEX_SESSION_KEY,
1225                                   temporaryGroupIndexMap );
1226             return mergedRepoDir;
1227         }
1228         catch ( RepositoryAdminException e )
1229         {
1230             throw new DavException( 500, e );
1231         }
1232         catch ( IndexMergerException e )
1233         {
1234             throw new DavException( 500, e );
1235         }
1236     }
1237
1238
1239     public void setServletAuth( ServletAuthenticator servletAuth )
1240     {
1241         this.servletAuth = servletAuth;
1242     }
1243
1244     public void setHttpAuth( HttpAuthenticator httpAuth )
1245     {
1246         this.httpAuth = httpAuth;
1247     }
1248
1249     public void setScheduler( RepositoryArchivaTaskScheduler scheduler )
1250     {
1251         this.scheduler = scheduler;
1252     }
1253
1254     public void setArchivaConfiguration( ArchivaConfiguration archivaConfiguration )
1255     {
1256         this.archivaConfiguration = archivaConfiguration;
1257     }
1258
1259     public void setRepositoryFactory( RepositoryContentFactory repositoryFactory )
1260     {
1261         this.repositoryFactory = repositoryFactory;
1262     }
1263
1264     public void setRepositoryRequest( RepositoryRequest repositoryRequest )
1265     {
1266         this.repositoryRequest = repositoryRequest;
1267     }
1268
1269     public void setConnectors( RepositoryProxyConnectors connectors )
1270     {
1271         this.connectors = connectors;
1272     }
1273
1274     public RemoteRepositoryAdmin getRemoteRepositoryAdmin()
1275     {
1276         return remoteRepositoryAdmin;
1277     }
1278
1279     public void setRemoteRepositoryAdmin( RemoteRepositoryAdmin remoteRepositoryAdmin )
1280     {
1281         this.remoteRepositoryAdmin = remoteRepositoryAdmin;
1282     }
1283 }