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

   1 package org.apache.archiva.scheduler.indexing;
   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.beans.ManagedRepository;
  23 import org.apache.maven.index.NexusIndexer;
  24 import org.apache.maven.index.context.IndexCreator;
  25 import org.apache.maven.index.context.IndexingContext;
  26 import org.apache.maven.index.context.UnsupportedExistingLuceneIndexException;
  27 import org.codehaus.plexus.taskqueue.Task;
  28 import org.slf4j.LoggerFactory;
  29
  30 import java.io.File;
  31 import java.io.IOException;
  32 import java.util.List;
  33
  34 public class ArtifactIndexingTask
  35     implements Task
  36 {
  37     public enum Action
  38     {
  39         ADD,
  40         DELETE,
  41         FINISH
  42     }
  43
  44     private final ManagedRepository repository;
  45
  46     private final File resourceFile;
  47
  48     private final Action action;
  49
  50     private final IndexingContext context;
  51
  52     private boolean executeOnEntireRepo = true;
  53
  54     /**
  55      * @since 1.4-M1
  56      */
  57     private boolean onlyUpdate = false;
  58
  59     public ArtifactIndexingTask( ManagedRepository repository, File resourceFile, Action action,
  60                                  IndexingContext context )
  61     {
  62         this.repository = repository;
  63         this.resourceFile = resourceFile;
  64         this.action = action;
  65         this.context = context;
  66     }
  67
  68     public ArtifactIndexingTask( ManagedRepository repository, File resourceFile, Action action,
  69                                  IndexingContext context, boolean executeOnEntireRepo )
  70     {
  71         this( repository, resourceFile, action, context );
  72         this.executeOnEntireRepo = executeOnEntireRepo;
  73     }
  74
  75     public ArtifactIndexingTask( ManagedRepository repository, File resourceFile, Action action,
  76                                  IndexingContext context, boolean executeOnEntireRepo, boolean onlyUpdate )
  77     {
  78         this( repository, resourceFile, action, context, executeOnEntireRepo );
  79         this.onlyUpdate = onlyUpdate;
  80     }
  81
  82     public boolean isExecuteOnEntireRepo()
  83     {
  84         return executeOnEntireRepo;
  85     }
  86
  87     public void setExecuteOnEntireRepo( boolean executeOnEntireRepo )
  88     {
  89         this.executeOnEntireRepo = executeOnEntireRepo;
  90     }
  91
  92     public long getMaxExecutionTime()
  93     {
  94         return 0;
  95     }
  96
  97     public File getResourceFile()
  98     {
  99         return resourceFile;
 100     }
 101
 102     public Action getAction()
 103     {
 104         return action;
 105     }
 106
 107     public ManagedRepository getRepository()
 108     {
 109         return repository;
 110     }
 111
 112     public IndexingContext getContext()
 113     {
 114         return context;
 115     }
 116
 117     public boolean isOnlyUpdate()
 118     {
 119         return onlyUpdate;
 120     }
 121
 122     public void setOnlyUpdate( boolean onlyUpdate )
 123     {
 124         this.onlyUpdate = onlyUpdate;
 125     }
 126
 127     @Override
 128     public int hashCode()
 129     {
 130         final int prime = 31;
 131         int result = 1;
 132         result = prime * result + action.hashCode();
 133         result = prime * result + repository.getId().hashCode();
 134         result = prime * result + ( ( resourceFile == null ) ? 0 : resourceFile.hashCode() );
 135         return result;
 136     }
 137
 138     @Override
 139     public boolean equals( Object obj )
 140     {
 141         if ( this == obj )
 142         {
 143             return true;
 144         }
 145         if ( obj == null )
 146         {
 147             return false;
 148         }
 149         if ( getClass() != obj.getClass() )
 150         {
 151             return false;
 152         }
 153         ArtifactIndexingTask other = (ArtifactIndexingTask) obj;
 154         if ( !action.equals( other.action ) )
 155         {
 156             return false;
 157         }
 158         if ( !repository.getId().equals( other.repository.getId() ) )
 159         {
 160             return false;
 161         }
 162         if ( resourceFile == null )
 163         {
 164             if ( other.resourceFile != null )
 165             {
 166                 return false;
 167             }
 168         }
 169         else if ( !resourceFile.equals( other.resourceFile ) )
 170         {
 171             return false;
 172         }
 173         return true;
 174     }
 175
 176
 177     @Override
 178     public String toString()
 179     {
 180         return "ArtifactIndexingTask [action=" + action + ", repositoryId=" + repository.getId() + ", resourceFile="
 181             + resourceFile + "]";
 182     }
 183
 184     /**
 185      * FIXME remove this static somewhere else !
 186      * @param repository
 187      * @param indexer
 188      * @param indexCreators
 189      * @return
 190      * @throws IOException
 191      * @throws UnsupportedExistingLuceneIndexException
 192      */
 193     public static IndexingContext createContext( ManagedRepository repository, NexusIndexer indexer,
 194                                                  List<? extends IndexCreator> indexCreators )
 195         throws IOException, UnsupportedExistingLuceneIndexException
 196     {
 197         IndexingContext context = indexer.getIndexingContexts().get( repository.getId() );
 198
 199         if ( context != null )
 200         {
 201             LoggerFactory.getLogger( ArtifactIndexingTask.class ).debug(
 202                 "skip adding repository with id {} as already exists", repository.getId() );
 203             return context;
 204         }
 205
 206
 207         String indexDir = repository.getIndexDirectory();
 208         File managedRepository = new File( repository.getLocation() );
 209
 210         File indexDirectory = null;
 211         if ( indexDir != null && !"".equals( indexDir ) )
 212         {
 213             indexDirectory = new File( repository.getIndexDirectory() );
 214         }
 215         else
 216         {
 217             indexDirectory = new File( managedRepository, ".indexer" );
 218         }
 219
 220
 221         context = indexer.addIndexingContext( repository.getId(), repository.getId(), managedRepository, indexDirectory,
 222                                               managedRepository.toURI().toURL().toExternalForm(),
 223                                               indexDirectory.toURI().toURL().toString(), indexCreators );
 224
 225         context.setSearchable( repository.isScanned() );
 226         return context;
 227     }
 228 }