org.gradle.internal.resource.transfer.DefaultExternalResourceConnector Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of gradle-api Show documentation
Show all versions of gradle-api Show documentation
Gradle 6.9.1 API redistribution.
/*
* Copyright 2015 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.gradle.internal.resource.transfer;
import org.gradle.api.Nullable;
import org.gradle.internal.resource.local.LocalResource;
import org.gradle.internal.resource.metadata.ExternalResourceMetaData;
import java.io.IOException;
import java.net.URI;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
public class DefaultExternalResourceConnector implements ExternalResourceConnector {
private static final String SYSPROP_KEY = "gradle.externalresources.recordstats";
private final static ExternalResourceAccessStats.Mode STATS_MODE = ExternalResourceAccessStats.Mode.valueOf(System.getProperty(SYSPROP_KEY, "none"));
private final static ExternalResourceAccessStats STATS = STATS_MODE.create();
private final ExternalResourceAccessor accessor;
private final ExternalResourceLister lister;
private final ExternalResourceUploader uploader;
public DefaultExternalResourceConnector(ExternalResourceAccessor accessor, ExternalResourceLister lister, ExternalResourceUploader uploader) {
this.accessor = accessor;
this.lister = lister;
this.uploader = uploader;
}
public static ExternalResourceAccessStats getStatistics() {
return STATS;
}
@Nullable
@Override
public ExternalResourceReadResponse openResource(URI location, boolean revalidate) {
STATS.resource(location);
return accessor.openResource(location, revalidate);
}
@Nullable
@Override
public ExternalResourceMetaData getMetaData(URI location, boolean revalidate) {
STATS.metadata(location);
return accessor.getMetaData(location, revalidate);
}
@Nullable
@Override
public List list(URI parent) {
STATS.list(parent);
return lister.list(parent);
}
@Override
public void upload(LocalResource resource, URI destination) throws IOException {
STATS.upload(destination);
uploader.upload(resource, destination);
}
public interface ExternalResourceAccessStats {
enum Mode {
none,
count,
trace;
public ExternalResourceAccessStats create() {
switch (this) {
case none:
return NoOpStats.INSTANCE;
case count:
return new CountingStats();
case trace:
return new MemoizingStats();
}
throw new UnsupportedOperationException();
}
}
void resource(URI location);
void metadata(URI location);
void list(URI parent);
void upload(URI destination);
void reset();
}
private static class NoOpStats implements ExternalResourceAccessStats {
public static final NoOpStats INSTANCE = new NoOpStats();
@Override
public void resource(URI location) {
}
@Override
public void metadata(URI location) {
}
@Override
public void list(URI parent) {
}
@Override
public void upload(URI destination) {
}
@Override
public void reset() {
}
@Override
public String toString() {
return "External resources access stats are not recorded. Run Gradle with -D" + SYSPROP_KEY + "=(count|trace) to record statistics";
}
}
private static class CountingStats implements ExternalResourceAccessStats {
private final AtomicInteger resourceCount = new AtomicInteger();
private final AtomicInteger metadataCount = new AtomicInteger();
private final AtomicInteger listCount = new AtomicInteger();
private final AtomicInteger uploadCount = new AtomicInteger();
@Override
public void resource(URI location) {
resourceCount.incrementAndGet();
}
@Override
public void metadata(URI location) {
metadataCount.incrementAndGet();
}
@Override
public void list(URI parent) {
listCount.incrementAndGet();
}
@Override
public void upload(URI destination) {
uploadCount.incrementAndGet();
}
@Override
public synchronized void reset() {
resourceCount.set(0);
metadataCount.set(0);
listCount.set(0);
uploadCount.set(0);
}
@Override
public String toString() {
final StringBuilder sb = new StringBuilder("External resources connector statistics: \n");
sb.append(" - Resources fetched : ").append(resourceCount.get()).append("\n");
sb.append(" - Metadata fetched : ").append(metadataCount.get()).append("\n");
sb.append(" - Lists : ").append(listCount.get()).append("\n");
sb.append(" - Uploads : ").append(uploadCount.get()).append("\n");
return sb.toString();
}
}
private static class MemoizingStats extends CountingStats {
private final Map resources = new HashMap();
private final Map metadata = new HashMap();
private final Map lists = new HashMap();
private final Map uploads = new HashMap();
private synchronized void record(Map container, URI uri) {
Integer count = container.get(uri);
if (count == null) {
container.put(uri, 1);
} else {
container.put(uri, count+1);
}
}
@Override
public void list(URI parent) {
record(lists, parent);
super.list(parent);
}
@Override
public void metadata(URI location) {
record(metadata, location);
super.metadata(location);
}
@Override
public void resource(URI location) {
record(resources, location);
super.resource(location);
}
@Override
public void upload(URI destination) {
record(uploads, destination);
super.upload(destination);
}
@Override
public synchronized void reset() {
super.reset();
resources.clear();
metadata.clear();
lists.clear();
uploads.clear();
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder(super.toString());
statsFor("fetched resources", resources, sb, 10);
statsFor("fetched metadata", metadata, sb, 10);
statsFor("lists queries", lists, sb, 10);
statsFor("uploaded URIs", uploads, sb, 10);
return sb.toString();
}
private void statsFor(String label, Map stats, StringBuilder sb, int max) {
if (stats.isEmpty()) {
return;
}
List> entries = new ArrayList>(stats.entrySet());
Collections.sort(entries, new Comparator>() {
@Override
public int compare(Map.Entry o1, Map.Entry o2) {
return o2.getValue() - o1.getValue();
}
});
sb.append("Top ").append(max).append(" most ").append(label).append("\n");
int cpt = 0;
for (Map.Entry entry : entries) {
sb.append(" ").append(entry.getKey()).append(" (").append(entry.getValue()).append(" times)\n");
if (++cpt==max) {
break;
}
}
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy