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.*;
  24 import org.apache.commons.lang.StringUtils;
  25 import org.apache.commons.lang.time.StopWatch;
  26 import org.apache.jackrabbit.oak.segment.file.InvalidFileStoreVersionException;
  27 import org.slf4j.Logger;
  28 import org.slf4j.LoggerFactory;
  29 import org.springframework.context.ApplicationContext;
  30 import org.springframework.stereotype.Service;
  31
  32 import javax.annotation.PreDestroy;
  33 import javax.inject.Inject;
  34 import javax.jcr.Repository;
  35 import javax.jcr.RepositoryException;
  36 import java.io.IOException;
  37 import java.nio.file.Path;
  38 import java.nio.file.Paths;
  39 import java.util.HashMap;
  40 import java.util.Map;
  41
  42 /**
  43  *
  44  */
  45 @Service( "repositorySessionFactory#jcr" )
  46 public class JcrRepositorySessionFactory extends AbstractRepositorySessionFactory
  47     implements RepositorySessionFactory
  48 {
  49
  50     private Logger logger = LoggerFactory.getLogger( getClass() );
  51
  52     @Inject
  53     private ApplicationContext applicationContext;
  54
  55     private Map<String, MetadataFacetFactory> metadataFacetFactories;
  56
  57     private Repository repository;
  58
  59     // Lazy evaluation to avoid problems with circular dependencies during initialization
  60     private MetadataResolver metadataResolver;
  61
  62     @Inject
  63     private RepositorySessionFactoryBean repositorySessionFactoryBean;
  64
  65     private RepositoryFactory repositoryFactory;
  66
  67     private JcrMetadataRepository jcrMetadataRepository;
  68
  69     @Override
  70     public RepositorySession createSession() throws MetadataRepositoryException
  71     {
  72         try
  73         {
  74             return new JcrSession( jcrMetadataRepository, getMetadataResolver() );
  75         }
  76         catch ( RepositoryException e )
  77         {
  78             // FIXME: a custom exception requires refactoring for callers to handle it
  79             throw new RuntimeException( e );
  80         }
  81     }
  82
  83     // Lazy evaluation to avoid problems with circular dependencies during initialization
  84     private MetadataResolver getMetadataResolver()
  85     {
  86         if ( this.metadataResolver == null )
  87         {
  88             this.metadataResolver = applicationContext.getBean( MetadataResolver.class );
  89         }
  90         return this.metadataResolver;
  91     }
  92
  93     protected void initialize()
  94     {
  95
  96         // skip initialisation if not jcr
  97         if ( repositorySessionFactoryBean!=null && !StringUtils.equals( repositorySessionFactoryBean.getId(), "jcr" ) )
  98         {
  99             return;
 100         }
 101
 102         StopWatch stopWatch = new StopWatch();
 103         stopWatch.start();
 104
 105         if (applicationContext!=null) {
 106             metadataFacetFactories = applicationContext.getBeansOfType(MetadataFacetFactory.class);
 107         }
 108         // olamy with spring the "id" is now "metadataFacetFactory#hint"
 109         // whereas was only hint with plexus so let remove  metadataFacetFactory#
 110         Map<String, MetadataFacetFactory> cleanedMetadataFacetFactories =
 111             new HashMap<>( metadataFacetFactories.size() );
 112
 113         for ( Map.Entry<String, MetadataFacetFactory> entry : metadataFacetFactories.entrySet() )
 114         {
 115             if (entry.getKey().contains("#")) {
 116                 cleanedMetadataFacetFactories.put( StringUtils.substringAfterLast( entry.getKey(), "#" ),
 117                         entry.getValue() );
 118
 119             } else {
 120                 cleanedMetadataFacetFactories.put(entry.getKey(), entry.getValue());
 121             }
 122         }
 123
 124         metadataFacetFactories = cleanedMetadataFacetFactories;
 125
 126         try
 127         {
 128
 129             repositoryFactory = new RepositoryFactory();
 130             // FIXME this need to be configurable
 131             Path directoryPath = Paths.get( System.getProperty( "appserver.base" ), "data/jcr" );
 132             repositoryFactory.setRepositoryPath( directoryPath );
 133             try {
 134                 repository = repositoryFactory.createRepository();
 135             } catch (InvalidFileStoreVersionException | IOException e) {
 136                 logger.error("Repository creation failed {}", e.getMessage());
 137                 throw new RuntimeException("Fatal error. Could not create metadata repository.");
 138             }
 139             jcrMetadataRepository = new JcrMetadataRepository( metadataFacetFactories, repository );
 140             try (JcrSession session = new JcrSession( jcrMetadataRepository, metadataResolver )) {
 141                 JcrMetadataRepository.initializeNodeTypes( session.getJcrSession() );
 142                 // Saves automatically with close
 143             }
 144         }
 145         catch ( RepositoryException e )
 146         {
 147             throw new RuntimeException( e.getMessage(), e );
 148         }
 149
 150         stopWatch.stop();
 151         logger.info( "time to initialize JcrRepositorySessionFactory: {}", stopWatch.getTime() );
 152     }
 153
 154     @Override
 155     protected void shutdown() {
 156         repositoryFactory.close();
 157     }
 158
 159     @PreDestroy
 160     public void close()
 161     {
 162         super.close();
 163     }
 164
 165     public void setMetadataResolver(MetadataResolver metadataResolver) {
 166         this.metadataResolver = metadataResolver;
 167     }
 168
 169     public JcrMetadataRepository getMetadataRepository() {
 170         return jcrMetadataRepository;
 171     }
 172
 173     public void setMetadataFacetFactories(Map<String, MetadataFacetFactory> metadataFacetFactories) {
 174         this.metadataFacetFactories = metadataFacetFactories;
 175     }
 176
 177 }