src/main/java/com/googlesource/gerrit/plugins/replicationstatus/ReplicationStatusAction.java - plugins/replication-status - Git at Google

 // Copyright (C) 2021 The Android Open Source Project
 //
 // 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 com.googlesource.gerrit.plugins.replicationstatus;

 import static com.googlesource.gerrit.plugins.replication.PushResultProcessing.resolveNodeName;
 import static com.googlesource.gerrit.plugins.replication.ReplicationFileBasedConfig.replaceName;
 import static com.googlesource.gerrit.plugins.replicationstatus.ReplicationStatus.CACHE_NAME;

 import com.google.common.cache.Cache;
 import com.google.common.collect.Maps;
 import com.google.common.flogger.FluentLogger;
 import com.google.gerrit.entities.Project;
 import com.google.gerrit.entities.Project.NameKey;
 import com.google.gerrit.extensions.restapi.AuthException;
 import com.google.gerrit.extensions.restapi.BadRequestException;
 import com.google.gerrit.extensions.restapi.ResourceConflictException;
 import com.google.gerrit.extensions.restapi.Response;
 import com.google.gerrit.extensions.restapi.RestReadView;
 import com.google.gerrit.server.git.GitRepositoryManager;
 import com.google.gerrit.server.permissions.GlobalPermission;
 import com.google.gerrit.server.permissions.PermissionBackend;
 import com.google.gerrit.server.permissions.PermissionBackendException;
 import com.google.gerrit.server.permissions.ProjectPermission;
 import com.google.inject.Inject;
 import com.google.inject.name.Named;
 import com.googlesource.gerrit.plugins.replication.ReplicationConfig;
 import com.googlesource.gerrit.plugins.replicationstatus.ProjectReplicationStatus.ProjectReplicationStatusResult;
 import java.io.IOException;
 import java.io.UnsupportedEncodingException;
 import java.net.URISyntaxException;
 import java.net.URLEncoder;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.stream.Collectors;
 import org.apache.commons.io.FilenameUtils;
 import org.eclipse.jgit.errors.ConfigInvalidException;
 import org.eclipse.jgit.errors.RepositoryNotFoundException;
 import org.eclipse.jgit.lib.Ref;
 import org.eclipse.jgit.lib.Repository;
 import org.eclipse.jgit.transport.URIish;

 class ReplicationStatusAction implements RestReadView<ReplicationStatusProjectRemoteResource> {
   private static final FluentLogger logger = FluentLogger.forEnclosingClass();

   private final PermissionBackend permissionBackend;
   private final GitRepositoryManager repoManager;
   private final Cache<ReplicationStatus.Key, ReplicationStatus> replicationStatusCache;
   private final List<RemoteURLConfiguration> remoteConfigurations;

   @Inject
   ReplicationStatusAction(
       PermissionBackend permissionBackend,
       GitRepositoryManager repoManager,
       @Named(CACHE_NAME) Cache<ReplicationStatus.Key, ReplicationStatus> replicationStatusCache,
       ReplicationConfig replicationConfig,
       ConfigParser configParser)
       throws ConfigInvalidException {
     this.permissionBackend = permissionBackend;
     this.repoManager = repoManager;
     this.replicationStatusCache = replicationStatusCache;
     this.remoteConfigurations = configParser.parseRemotes(replicationConfig.getConfig());
   }

   @Override
   public Response<ProjectReplicationStatus> apply(ReplicationStatusProjectRemoteResource resource)
       throws AuthException, PermissionBackendException, BadRequestException,
           ResourceConflictException, IOException {

     Project.NameKey projectNameKey = resource.getProjectNameKey();
     String remoteName = resource.getRemote();
     Optional<RemoteURLConfiguration> remoteConfig =
         remoteConfigurations.stream()
             .filter(config -> config.getName().equals(remoteName))
             .findFirst();

     checkIsOwnerOrAdmin(projectNameKey);

     try (Repository git = repoManager.openRepository(projectNameKey)) {
       List<Ref> refs = git.getRefDatabase().getRefs();
       Map<String, RemoteReplicationStatus> remoteStatuses =
           remoteConfig
               .map(config -> getRemoteReplicationStatuses(config, projectNameKey, refs))
               .orElse(Collections.emptyMap());

       ProjectReplicationStatus.ProjectReplicationStatusResult overallStatus =
           getOverallStatus(remoteStatuses);
       ProjectReplicationStatus projectStatus =
           ProjectReplicationStatus.create(remoteStatuses, overallStatus, projectNameKey.get());

       return Response.ok(projectStatus);

     } catch (RepositoryNotFoundException e) {
       throw new BadRequestException(
           String.format("Project %s does not exist", projectNameKey.get()));
     }
   }

   private Map<String, RemoteReplicationStatus> getRemoteReplicationStatuses(
       RemoteURLConfiguration config, NameKey projectNameKey, List<Ref> refs) {
     return config.getUrls().stream()
         .map(url -> getTargetURL(projectNameKey, config, url))
         .filter(Optional::isPresent)
         .map(
             targetUrl ->
                 Maps.immutableEntry(
                     targetUrl.get(),
                     RemoteReplicationStatus.create(
                         getRefStatuses(projectNameKey, refs, targetUrl.get()))))
         .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
   }

   private ProjectReplicationStatusResult getOverallStatus(
       Map<String, RemoteReplicationStatus> remoteStatuses) {
     return remoteStatuses.values().stream()
         .flatMap(status -> status.status().values().stream())
         .filter(ReplicationStatus::isFailure)
         .findFirst()
         .map(status -> ProjectReplicationStatus.ProjectReplicationStatusResult.FAILED)
         .orElse(ProjectReplicationStatus.ProjectReplicationStatusResult.OK);
   }

   private Map<String, ReplicationStatus> getRefStatuses(
       Project.NameKey projectNameKey, List<Ref> refs, String uri) {
     return refs.stream()
         .map(ref -> ReplicationStatus.Key.create(projectNameKey, uri, ref.getName()))
         .map(
             key ->
                 Maps.immutableEntry(
                     key.ref(), Optional.ofNullable(replicationStatusCache.getIfPresent(key))))
         .filter(e -> e.getValue().isPresent())
         .collect(Collectors.toMap(Map.Entry::getKey, e -> e.getValue().get()));
   }

   private Optional<String> getTargetURL(
       Project.NameKey projectNameKey, RemoteURLConfiguration config, String url) {
     try {
       return Optional.of(resolveNodeName(getURI(config, new URIish(url), projectNameKey)));
     } catch (URISyntaxException e) {
       logger.atSevere().withCause(e).log(
           "Cannot resolve target URI for template: %s and project name: %s", url, projectNameKey);
       return Optional.empty();
     }
   }

   /**
    * This method was copied from replication plugin where the method is in protected scope {@link
    * com.googlesource.gerrit.plugins.replication.Destination#getURI(URIish, NameKey)}
    */
   @SuppressWarnings("javadoc")
   private URIish getURI(RemoteURLConfiguration config, URIish template, Project.NameKey project) {
     String name = project.get();
     if (needsUrlEncoding(template)) {
       name = encode(name);
     }
     String remoteNameStyle = config.getRemoteNameStyle();
     if (remoteNameStyle.equals("dash")) {
       name = name.replace("/", "-");
     } else if (remoteNameStyle.equals("underscore")) {
       name = name.replace("/", "_");
     } else if (remoteNameStyle.equals("basenameOnly")) {
       name = FilenameUtils.getBaseName(name);
     } else if (!remoteNameStyle.equals("slash")) {
       logger.atFine().log("Unknown remoteNameStyle: %s, falling back to slash", remoteNameStyle);
     }
     String replacedPath = replaceName(template.getPath(), name, config.isSingleProjectMatch());
     return (replacedPath != null) ? template.setPath(replacedPath) : template;
   }

   /**
    * This method was copied from replication plugin where the method is in protected scope {@link
    * com.googlesource.gerrit.plugins.replication.Destination#needsUrlEncoding(URIish)}
    */
   @SuppressWarnings("javadoc")
   private static boolean needsUrlEncoding(URIish uri) {
     return "http".equalsIgnoreCase(uri.getScheme())
         || "https".equalsIgnoreCase(uri.getScheme())
         || "amazon-s3".equalsIgnoreCase(uri.getScheme());
   }

   /**
    * This method was copied from replication plugin where the method is in protected scope {@link
    * com.googlesource.gerrit.plugins.replication.Destination#encode(String)}
    */
   @SuppressWarnings("javadoc")
   private static String encode(String str) {
     try {
       // Some cleanup is required. The '/' character is always encoded as %2F
       // however remote servers will expect it to be not encoded as part of the
       // path used to the repository. Space is incorrectly encoded as '+' for this
       // context. In the path part of a URI space should be %20, but in form data
       // space is '+'. Our cleanup replace fixes these two issues.
       return URLEncoder.encode(str, "UTF-8").replaceAll("%2[fF]", "/").replace("+", "%20");
     } catch (UnsupportedEncodingException e) {
       throw new RuntimeException(e);
     }
   }

   private void checkIsOwnerOrAdmin(Project.NameKey project) throws AuthException {
     if (!permissionBackend.currentUser().testOrFalse(GlobalPermission.ADMINISTRATE_SERVER)
         && !permissionBackend
             .currentUser()
             .project(project)
             .testOrFalse(ProjectPermission.WRITE_CONFIG)) {
       throw new AuthException("Administrate Server or Project owner required");
     }
   }
 }
	// Copyright (C) 2021 The Android Open Source Project
	//
	// 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 com.googlesource.gerrit.plugins.replicationstatus;

	import static com.googlesource.gerrit.plugins.replication.PushResultProcessing.resolveNodeName;
	import static com.googlesource.gerrit.plugins.replication.ReplicationFileBasedConfig.replaceName;
	import static com.googlesource.gerrit.plugins.replicationstatus.ReplicationStatus.CACHE_NAME;

	import com.google.common.cache.Cache;
	import com.google.common.collect.Maps;
	import com.google.common.flogger.FluentLogger;
	import com.google.gerrit.entities.Project;
	import com.google.gerrit.entities.Project.NameKey;
	import com.google.gerrit.extensions.restapi.AuthException;
	import com.google.gerrit.extensions.restapi.BadRequestException;
	import com.google.gerrit.extensions.restapi.ResourceConflictException;
	import com.google.gerrit.extensions.restapi.Response;
	import com.google.gerrit.extensions.restapi.RestReadView;
	import com.google.gerrit.server.git.GitRepositoryManager;
	import com.google.gerrit.server.permissions.GlobalPermission;
	import com.google.gerrit.server.permissions.PermissionBackend;
	import com.google.gerrit.server.permissions.PermissionBackendException;
	import com.google.gerrit.server.permissions.ProjectPermission;
	import com.google.inject.Inject;
	import com.google.inject.name.Named;
	import com.googlesource.gerrit.plugins.replication.ReplicationConfig;
	import com.googlesource.gerrit.plugins.replicationstatus.ProjectReplicationStatus.ProjectReplicationStatusResult;
	import java.io.IOException;
	import java.io.UnsupportedEncodingException;
	import java.net.URISyntaxException;
	import java.net.URLEncoder;
	import java.util.Collections;
	import java.util.List;
	import java.util.Map;
	import java.util.Optional;
	import java.util.stream.Collectors;
	import org.apache.commons.io.FilenameUtils;
	import org.eclipse.jgit.errors.ConfigInvalidException;
	import org.eclipse.jgit.errors.RepositoryNotFoundException;
	import org.eclipse.jgit.lib.Ref;
	import org.eclipse.jgit.lib.Repository;
	import org.eclipse.jgit.transport.URIish;

	class ReplicationStatusAction implements RestReadView<ReplicationStatusProjectRemoteResource> {
	private static final FluentLogger logger = FluentLogger.forEnclosingClass();

	private final PermissionBackend permissionBackend;
	private final GitRepositoryManager repoManager;
	private final Cache<ReplicationStatus.Key, ReplicationStatus> replicationStatusCache;
	private final List<RemoteURLConfiguration> remoteConfigurations;

	@Inject
	ReplicationStatusAction(
	PermissionBackend permissionBackend,
	GitRepositoryManager repoManager,
	@Named(CACHE_NAME) Cache<ReplicationStatus.Key, ReplicationStatus> replicationStatusCache,
	ReplicationConfig replicationConfig,
	ConfigParser configParser)
	throws ConfigInvalidException {
	this.permissionBackend = permissionBackend;
	this.repoManager = repoManager;
	this.replicationStatusCache = replicationStatusCache;
	this.remoteConfigurations = configParser.parseRemotes(replicationConfig.getConfig());
	}

	@Override
	public Response<ProjectReplicationStatus> apply(ReplicationStatusProjectRemoteResource resource)
	throws AuthException, PermissionBackendException, BadRequestException,
	ResourceConflictException, IOException {

	Project.NameKey projectNameKey = resource.getProjectNameKey();
	String remoteName = resource.getRemote();
	Optional<RemoteURLConfiguration> remoteConfig =
	remoteConfigurations.stream()
	.filter(config -> config.getName().equals(remoteName))
	.findFirst();

	checkIsOwnerOrAdmin(projectNameKey);

	try (Repository git = repoManager.openRepository(projectNameKey)) {
	List<Ref> refs = git.getRefDatabase().getRefs();
	Map<String, RemoteReplicationStatus> remoteStatuses =
	remoteConfig
	.map(config -> getRemoteReplicationStatuses(config, projectNameKey, refs))
	.orElse(Collections.emptyMap());

	ProjectReplicationStatus.ProjectReplicationStatusResult overallStatus =
	getOverallStatus(remoteStatuses);
	ProjectReplicationStatus projectStatus =
	ProjectReplicationStatus.create(remoteStatuses, overallStatus, projectNameKey.get());

	return Response.ok(projectStatus);

	} catch (RepositoryNotFoundException e) {
	throw new BadRequestException(
	String.format("Project %s does not exist", projectNameKey.get()));
	}
	}

	private Map<String, RemoteReplicationStatus> getRemoteReplicationStatuses(
	RemoteURLConfiguration config, NameKey projectNameKey, List<Ref> refs) {
	return config.getUrls().stream()
	.map(url -> getTargetURL(projectNameKey, config, url))
	.filter(Optional::isPresent)
	.map(
	targetUrl ->
	Maps.immutableEntry(
	targetUrl.get(),
	RemoteReplicationStatus.create(
	getRefStatuses(projectNameKey, refs, targetUrl.get()))))
	.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
	}

	private ProjectReplicationStatusResult getOverallStatus(
	Map<String, RemoteReplicationStatus> remoteStatuses) {
	return remoteStatuses.values().stream()
	.flatMap(status -> status.status().values().stream())
	.filter(ReplicationStatus::isFailure)
	.findFirst()
	.map(status -> ProjectReplicationStatus.ProjectReplicationStatusResult.FAILED)
	.orElse(ProjectReplicationStatus.ProjectReplicationStatusResult.OK);
	}

	private Map<String, ReplicationStatus> getRefStatuses(
	Project.NameKey projectNameKey, List<Ref> refs, String uri) {
	return refs.stream()
	.map(ref -> ReplicationStatus.Key.create(projectNameKey, uri, ref.getName()))
	.map(
	key ->
	Maps.immutableEntry(
	key.ref(), Optional.ofNullable(replicationStatusCache.getIfPresent(key))))
	.filter(e -> e.getValue().isPresent())
	.collect(Collectors.toMap(Map.Entry::getKey, e -> e.getValue().get()));
	}

	private Optional<String> getTargetURL(
	Project.NameKey projectNameKey, RemoteURLConfiguration config, String url) {
	try {
	return Optional.of(resolveNodeName(getURI(config, new URIish(url), projectNameKey)));
	} catch (URISyntaxException e) {
	logger.atSevere().withCause(e).log(
	"Cannot resolve target URI for template: %s and project name: %s", url, projectNameKey);
	return Optional.empty();
	}
	}

	/**
	* This method was copied from replication plugin where the method is in protected scope {@link
	* com.googlesource.gerrit.plugins.replication.Destination#getURI(URIish, NameKey)}
	*/
	@SuppressWarnings("javadoc")
	private URIish getURI(RemoteURLConfiguration config, URIish template, Project.NameKey project) {
	String name = project.get();
	if (needsUrlEncoding(template)) {
	name = encode(name);
	}
	String remoteNameStyle = config.getRemoteNameStyle();
	if (remoteNameStyle.equals("dash")) {
	name = name.replace("/", "-");
	} else if (remoteNameStyle.equals("underscore")) {
	name = name.replace("/", "_");
	} else if (remoteNameStyle.equals("basenameOnly")) {
	name = FilenameUtils.getBaseName(name);
	} else if (!remoteNameStyle.equals("slash")) {
	logger.atFine().log("Unknown remoteNameStyle: %s, falling back to slash", remoteNameStyle);
	}
	String replacedPath = replaceName(template.getPath(), name, config.isSingleProjectMatch());
	return (replacedPath != null) ? template.setPath(replacedPath) : template;
	}

	/**
	* This method was copied from replication plugin where the method is in protected scope {@link
	* com.googlesource.gerrit.plugins.replication.Destination#needsUrlEncoding(URIish)}
	*/
	@SuppressWarnings("javadoc")
	private static boolean needsUrlEncoding(URIish uri) {
	return "http".equalsIgnoreCase(uri.getScheme())
	\|\| "https".equalsIgnoreCase(uri.getScheme())
	\|\| "amazon-s3".equalsIgnoreCase(uri.getScheme());
	}

	/**
	* This method was copied from replication plugin where the method is in protected scope {@link
	* com.googlesource.gerrit.plugins.replication.Destination#encode(String)}
	*/
	@SuppressWarnings("javadoc")
	private static String encode(String str) {
	try {
	// Some cleanup is required. The '/' character is always encoded as %2F
	// however remote servers will expect it to be not encoded as part of the
	// path used to the repository. Space is incorrectly encoded as '+' for this
	// context. In the path part of a URI space should be %20, but in form data
	// space is '+'. Our cleanup replace fixes these two issues.
	return URLEncoder.encode(str, "UTF-8").replaceAll("%2[fF]", "/").replace("+", "%20");
	} catch (UnsupportedEncodingException e) {
	throw new RuntimeException(e);
	}
	}

	private void checkIsOwnerOrAdmin(Project.NameKey project) throws AuthException {
	if (!permissionBackend.currentUser().testOrFalse(GlobalPermission.ADMINISTRATE_SERVER)
	&& !permissionBackend
	.currentUser()
	.project(project)
	.testOrFalse(ProjectPermission.WRITE_CONFIG)) {
	throw new AuthException("Administrate Server or Project owner required");
	}
	}
	}