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

   1 package org.apache.archiva.metadata.repository.jcr;
   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.metadata.model.MetadataFacetFactory;
  23 import org.apache.archiva.metadata.repository.MetadataRepository;
  24 import org.apache.archiva.metadata.repository.MetadataResolver;
  25 import org.apache.archiva.metadata.repository.RepositorySession;
  26 import org.apache.archiva.metadata.repository.RepositorySessionFactory;
  27 import org.apache.archiva.metadata.repository.RepositorySessionFactoryBean;
  28 import org.apache.commons.lang.StringUtils;
  29 import org.apache.commons.lang.time.StopWatch;
  30 import org.slf4j.Logger;
  31 import org.slf4j.LoggerFactory;
  32 import org.springframework.context.ApplicationContext;
  33 import org.springframework.stereotype.Service;
  34
  35 import javax.annotation.PostConstruct;
  36 import javax.inject.Inject;
  37 import javax.jcr.Repository;
  38 import javax.jcr.RepositoryException;
  39 import java.nio.file.Path;
  40 import java.nio.file.Paths;
  41 import java.util.HashMap;
  42 import java.util.Map;
  43
  44 /**
  45  *
  46  */
  47 @Service("repositorySessionFactory#jcr")
  48 public class JcrRepositorySessionFactory
  49     implements RepositorySessionFactory
  50 {
  51
  52     private Logger logger = LoggerFactory.getLogger( getClass() );
  53
  54     @Inject
  55     private ApplicationContext applicationContext;
  56
  57     private Map<String, MetadataFacetFactory> metadataFacetFactories;
  58
  59     private Repository repository;
  60
  61     // Lazy evaluation to avoid problems with circular dependencies during initialization
  62     private MetadataResolver metadataResolver;
  63
  64     @Inject
  65     private RepositorySessionFactoryBean repositorySessionFactoryBean;
  66
  67     @Override
  68     public RepositorySession createSession()
  69     {
  70         try
  71         {
  72             // FIXME: is this the right separation? or should a JCR session object contain the JCR session information?
  73             //  such a change might allow us to avoid creating two objects for each request. It would also clear up
  74             //  the ambiguities in the API where session & repository are the inverse of JCR; and the resolver is
  75             //  retrieved from the session but must have it passed in. These should be reviewed before finalising the
  76             //  API.
  77             MetadataRepository metadataRepository = new JcrMetadataRepository( metadataFacetFactories, repository );
  78
  79             return new RepositorySession( metadataRepository, getMetadataResolver() );
  80         }
  81         catch ( RepositoryException e )
  82         {
  83             // FIXME: a custom exception requires refactoring for callers to handle it
  84             throw new RuntimeException( e );
  85         }
  86     }
  87
  88     // Lazy evaluation to avoid problems with circular dependencies during initialization
  89     private MetadataResolver getMetadataResolver() {
  90         if (this.metadataResolver==null) {
  91             this.metadataResolver = applicationContext.getBean( MetadataResolver.class );
  92         }
  93         return this.metadataResolver;
  94     }
  95
  96     @PostConstruct
  97     public void initialize()
  98         throws Exception
  99     {
 100
 101         // skip initialisation if not jcr
 102         if ( !StringUtils.equals( repositorySessionFactoryBean.getId(), "jcr" ) )
 103         {
 104             return;
 105         }
 106
 107         StopWatch stopWatch = new StopWatch();
 108         stopWatch.start();
 109
 110         metadataFacetFactories = applicationContext.getBeansOfType( MetadataFacetFactory.class );
 111         // olamy with spring the "id" is now "metadataFacetFactory#hint"
 112         // whereas was only hint with plexus so let remove  metadataFacetFactory#
 113         Map<String, MetadataFacetFactory> cleanedMetadataFacetFactories =
 114             new HashMap<>( metadataFacetFactories.size() );
 115
 116         for ( Map.Entry<String, MetadataFacetFactory> entry : metadataFacetFactories.entrySet() )
 117         {
 118             cleanedMetadataFacetFactories.put( StringUtils.substringAfterLast( entry.getKey(), "#" ),
 119                                                entry.getValue() );
 120         }
 121
 122         metadataFacetFactories = cleanedMetadataFacetFactories;
 123
 124         JcrMetadataRepository metadataRepository = null;
 125         try
 126         {
 127             RepositoryFactory factory = new RepositoryFactory();
 128             // FIXME this need to be configurable
 129             Path directoryPath = Paths.get(System.getProperty( "appserver.base" ), "data/jcr");
 130             factory.setRepositoryPath( directoryPath );
 131             repository = factory.createRepository();
 132             metadataRepository = new JcrMetadataRepository( metadataFacetFactories, repository );
 133             JcrMetadataRepository.initialize( metadataRepository.getJcrSession() );
 134         }
 135         catch ( RepositoryException e )
 136         {
 137             throw new RuntimeException( e.getMessage(), e );
 138         }
 139         finally
 140         {
 141             if ( metadataRepository != null )
 142             {
 143                 metadataRepository.close();
 144             }
 145         }
 146
 147         stopWatch.stop();
 148         logger.info( "time to initialize JcrRepositorySessionFactory: {}", stopWatch.getTime() );
 149     }
 150 }