View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  You may obtain a copy of the License at
9    *
10   *   http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing,
13   * software distributed under the License is distributed on an
14   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   * KIND, either express or implied.  See the License for the
16   * specific language governing permissions and limitations
17   * under the License.
18   */
19  package org.eclipse.aether.internal.impl.filter;
20  
21  import java.util.ArrayList;
22  import java.util.Collection;
23  import java.util.List;
24  
25  import org.eclipse.aether.repository.RemoteRepository;
26  import org.eclipse.aether.spi.connector.ArtifactDownload;
27  import org.eclipse.aether.spi.connector.ArtifactUpload;
28  import org.eclipse.aether.spi.connector.MetadataDownload;
29  import org.eclipse.aether.spi.connector.MetadataUpload;
30  import org.eclipse.aether.spi.connector.RepositoryConnector;
31  import org.eclipse.aether.spi.connector.filter.RemoteRepositoryFilter;
32  import org.eclipse.aether.transfer.ArtifactNotFoundException;
33  import org.eclipse.aether.transfer.MetadataNotFoundException;
34  
35  import static java.util.Objects.requireNonNull;
36  
37  /**
38   * A filtering connector that filter transfers using remote repository filter and delegates to another connector.
39   *
40   * @since 1.9.0
41   */
42  public final class FilteringRepositoryConnector implements RepositoryConnector {
43      private final RemoteRepository remoteRepository;
44  
45      private final RepositoryConnector delegate;
46  
47      private final RemoteRepositoryFilter remoteRepositoryFilter;
48  
49      public FilteringRepositoryConnector(
50              RemoteRepository remoteRepository,
51              RepositoryConnector delegate,
52              RemoteRepositoryFilter remoteRepositoryFilter) {
53          this.remoteRepository = requireNonNull(remoteRepository);
54          this.delegate = requireNonNull(delegate);
55          this.remoteRepositoryFilter = requireNonNull(remoteRepositoryFilter);
56      }
57  
58      @Override
59      public void close() {
60          delegate.close();
61      }
62  
63      @Override
64      public void get(
65              Collection<? extends ArtifactDownload> artifactDownloads,
66              Collection<? extends MetadataDownload> metadataDownloads) {
67          List<ArtifactDownload> filteredArtifactDownloads = null;
68          if (artifactDownloads != null && !artifactDownloads.isEmpty()) {
69              filteredArtifactDownloads = new ArrayList<>(artifactDownloads.size());
70              for (ArtifactDownload artifactDownload : artifactDownloads) {
71                  RemoteRepositoryFilter.Result result =
72                          remoteRepositoryFilter.acceptArtifact(remoteRepository, artifactDownload.getArtifact());
73                  if (result.isAccepted()) {
74                      filteredArtifactDownloads.add(artifactDownload);
75                  } else {
76                      artifactDownload.setException(new ArtifactNotFoundException(
77                              artifactDownload.getArtifact(), remoteRepository, result.reasoning()));
78                  }
79              }
80          }
81          List<MetadataDownload> filteredMetadataDownloads = null;
82          if (metadataDownloads != null && !metadataDownloads.isEmpty()) {
83              filteredMetadataDownloads = new ArrayList<>(metadataDownloads.size());
84              for (MetadataDownload metadataDownload : metadataDownloads) {
85                  RemoteRepositoryFilter.Result result =
86                          remoteRepositoryFilter.acceptMetadata(remoteRepository, metadataDownload.getMetadata());
87                  if (result.isAccepted()) {
88                      filteredMetadataDownloads.add(metadataDownload);
89                  } else {
90                      metadataDownload.setException(new MetadataNotFoundException(
91                              metadataDownload.getMetadata(), remoteRepository, result.reasoning()));
92                  }
93              }
94          }
95          delegate.get(filteredArtifactDownloads, filteredMetadataDownloads);
96      }
97  
98      @Override
99      public void put(
100             Collection<? extends ArtifactUpload> artifactUploads,
101             Collection<? extends MetadataUpload> metadataUploads) {
102         delegate.put(artifactUploads, metadataUploads);
103     }
104 
105     @Override
106     public String toString() {
107         return "filtered(" + delegate.toString() + ")";
108     }
109 }