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

   1 package org.apache.archiva.repository;
   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.repository.content.RepositoryStorage;
  23 import org.apache.archiva.repository.content.StorageAsset;
  24 import org.apache.commons.collections4.map.ListOrderedMap;
  25
  26 import java.io.IOException;
  27 import java.io.InputStream;
  28 import java.nio.file.Path;
  29 import java.util.List;
  30 import java.util.Locale;
  31 import java.util.concurrent.locks.ReadWriteLock;
  32 import java.util.concurrent.locks.ReentrantReadWriteLock;
  33 import java.util.function.Consumer;
  34
  35 /**
  36  * Abstract repository group implementation.
  37  *
  38  */
  39 public class AbstractRepositoryGroup extends AbstractRepository implements EditableRepositoryGroup  {
  40
  41     private ListOrderedMap<String, ManagedRepository> repositories = new ListOrderedMap<>();
  42
  43     private String mergedIndexPath;
  44
  45     private int mergedIndexTTL;
  46
  47     private final ReadWriteLock rwl = new ReentrantReadWriteLock();
  48
  49     private RepositoryStorage storage;
  50
  51     private RepositoryCapabilities capabilities;
  52
  53     public AbstractRepositoryGroup(RepositoryType type, String id, String name, Path repositoryBase) {
  54         super(type, id, name, repositoryBase);
  55     }
  56
  57     public AbstractRepositoryGroup(Locale primaryLocale, RepositoryType type, String id, String name, Path repositoryBase) {
  58         super(primaryLocale, type, id, name, repositoryBase);
  59     }
  60
  61     @Override
  62     public boolean hasIndex() {
  63         return true;
  64     }
  65
  66     @Override
  67     public RepositoryCapabilities getCapabilities() {
  68         return capabilities;
  69     }
  70
  71
  72     @Override
  73     public void clearRepositories() {
  74         rwl.writeLock().lock();
  75         try {
  76             repositories.clear();
  77         } finally {
  78             rwl.writeLock().unlock();
  79         }
  80     }
  81
  82     @Override
  83     public void setRepositories(List<ManagedRepository> repositories) {
  84         rwl.writeLock().lock();
  85         try {
  86             repositories.clear();
  87             repositories.addAll(repositories);
  88         } finally {
  89             rwl.writeLock().unlock();
  90         }
  91     }
  92
  93     @Override
  94     public void addRepository(ManagedRepository repository) {
  95         rwl.writeLock().lock();
  96         try {
  97             repositories.put(repository.getId(), repository);
  98         } finally {
  99             rwl.writeLock().unlock();
 100         }
 101     }
 102
 103     @Override
 104     public void addRepository(int index, ManagedRepository repository) {
 105         rwl.writeLock().lock();
 106         try {
 107             repositories.put(index, repository.getId(), repository);
 108         } finally {
 109             rwl.writeLock().unlock();
 110         }
 111     }
 112
 113     @Override
 114     public boolean removeRepository(ManagedRepository repository) {
 115         rwl.writeLock().lock();
 116         try {
 117             return repositories.remove(repository.getId(), repository);
 118         } finally {
 119             rwl.writeLock().unlock();
 120         }
 121     }
 122
 123     @Override
 124     public ManagedRepository removeRepository(String repoId) {
 125         rwl.writeLock().lock();
 126         try {
 127             return repositories.remove(repoId);
 128         } finally {
 129             rwl.writeLock().unlock();
 130         }
 131     }
 132
 133     @Override
 134     public void setMergedIndexPath(String path) {
 135         this.mergedIndexPath = path;
 136     }
 137
 138     @Override
 139     public void setMergedIndexTTL(int timeInSeconds) {
 140         this.mergedIndexTTL = timeInSeconds;
 141     }
 142
 143     @Override
 144     public List<ManagedRepository> getRepositories() {
 145         rwl.readLock().lock();
 146         try {
 147             return repositories.valueList();
 148         } finally {
 149             rwl.readLock().unlock();
 150         }
 151     }
 152
 153     @Override
 154     public boolean contains(ManagedRepository repository) {
 155         rwl.readLock().lock();
 156         try {
 157             return repositories.containsValue(repository);
 158         } finally {
 159             rwl.readLock().unlock();
 160         }
 161     }
 162
 163     @Override
 164     public boolean contains(String id) {
 165         rwl.readLock().lock();
 166         try {
 167             return repositories.containsKey(id);
 168         } finally {
 169             rwl.readLock().unlock();
 170         }
 171     }
 172
 173     @Override
 174     public StorageAsset getMergedIndexPath() {
 175         return storage.getAsset(mergedIndexPath);
 176     }
 177
 178     @Override
 179     public int getMergedIndexTTL() {
 180         return mergedIndexTTL;
 181     }
 182
 183     @Override
 184     public StorageAsset getAsset(String path) {
 185         return storage.getAsset(path);
 186     }
 187
 188     @Override
 189     public void consumeData(StorageAsset asset, Consumer<InputStream> consumerFunction, boolean readLock) throws IOException {
 190         storage.consumeData(asset, consumerFunction, readLock);
 191     }
 192
 193     @Override
 194     public StorageAsset addAsset(String path, boolean container) {
 195         return storage.addAsset(path, container);
 196     }
 197
 198     @Override
 199     public void removeAsset(StorageAsset asset) throws IOException {
 200         storage.removeAsset(asset);
 201     }
 202
 203     @Override
 204     public StorageAsset moveAsset(StorageAsset origin, String destination) throws IOException {
 205         return storage.moveAsset(origin, destination);
 206     }
 207
 208     @Override
 209     public StorageAsset copyAsset(StorageAsset origin, String destination) throws IOException {
 210         return storage.copyAsset(origin, destination);
 211     }
 212
 213     protected void setStorage(RepositoryStorage storage) {
 214         this.storage = storage;
 215     }
 216
 217     protected void setCapabilities(RepositoryCapabilities capabilities) {
 218         this.capabilities = capabilities;
 219     }
 220 }