src/main/java/com/google/devtools/build/lib/remote/RemoteServerCapabilities.java - bazel - Git at Google

 // Copyright 2018 The Bazel Authors. All rights reserved.
 //
 // 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.google.devtools.build.lib.remote;

 import build.bazel.remote.execution.v2.CacheCapabilities;
 import build.bazel.remote.execution.v2.CapabilitiesGrpc;
 import build.bazel.remote.execution.v2.CapabilitiesGrpc.CapabilitiesBlockingStub;
 import build.bazel.remote.execution.v2.Compressor;
 import build.bazel.remote.execution.v2.DigestFunction;
 import build.bazel.remote.execution.v2.ExecutionCapabilities;
 import build.bazel.remote.execution.v2.GetCapabilitiesRequest;
 import build.bazel.remote.execution.v2.PriorityCapabilities;
 import build.bazel.remote.execution.v2.PriorityCapabilities.PriorityRange;
 import build.bazel.remote.execution.v2.RequestMetadata;
 import build.bazel.remote.execution.v2.ServerCapabilities;
 import com.google.common.collect.ImmutableList;
 import com.google.devtools.build.lib.remote.common.RemoteActionExecutionContext;
 import com.google.devtools.build.lib.remote.options.RemoteOptions;
 import com.google.devtools.build.lib.remote.util.TracingMetadataUtils;
 import io.grpc.CallCredentials;
 import io.grpc.Channel;
 import io.grpc.StatusRuntimeException;
 import java.io.IOException;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 import javax.annotation.Nullable;

 /** Fetches the ServerCapabilities of the remote execution/cache server. */
 class RemoteServerCapabilities {

   @Nullable private final String instanceName;
   private final ReferenceCountedChannel channel;
   @Nullable private final CallCredentials callCredentials;
   private final long callTimeoutSecs;
   private final RemoteRetrier retrier;

   public RemoteServerCapabilities(
       @Nullable String instanceName,
       ReferenceCountedChannel channel,
       @Nullable CallCredentials callCredentials,
       long callTimeoutSecs,
       RemoteRetrier retrier) {
     this.instanceName = instanceName;
     this.channel = channel;
     this.callCredentials = callCredentials;
     this.callTimeoutSecs = callTimeoutSecs;
     this.retrier = retrier;
   }

   private CapabilitiesBlockingStub capabilitiesBlockingStub(
       RemoteActionExecutionContext context, Channel channel) {
     return CapabilitiesGrpc.newBlockingStub(channel)
         .withInterceptors(
             TracingMetadataUtils.attachMetadataInterceptor(context.getRequestMetadata()))
         .withCallCredentials(callCredentials)
         .withDeadlineAfter(callTimeoutSecs, TimeUnit.SECONDS);
   }

   public ServerCapabilities get(String buildRequestId, String commandId)
       throws IOException, InterruptedException {
     RequestMetadata metadata =
         TracingMetadataUtils.buildMetadata(buildRequestId, commandId, "capabilities", null);
     RemoteActionExecutionContext context = RemoteActionExecutionContext.create(metadata);
     try {
       GetCapabilitiesRequest request =
           instanceName == null
               ? GetCapabilitiesRequest.getDefaultInstance()
               : GetCapabilitiesRequest.newBuilder().setInstanceName(instanceName).build();
       return retrier.execute(
           () ->
               channel.withChannelBlocking(
                   channel -> capabilitiesBlockingStub(context, channel).getCapabilities(request)));
     } catch (StatusRuntimeException e) {
       if (e.getCause() instanceof IOException) {
         throw (IOException) e.getCause();
       }
       throw new IOException(e);
     }
   }

   static class ClientServerCompatibilityStatus {

     private final List<String> warnings;
     private final List<String> errors;

     private ClientServerCompatibilityStatus(List<String> warnings, List<String> errors) {
       this.warnings = warnings;
       this.errors = errors;
     }

     static class Builder {
       private final ImmutableList.Builder<String> warnings = ImmutableList.builder();
       private final ImmutableList.Builder<String> errors = ImmutableList.builder();

       public void addWarning(String message) {
         warnings.add(message);
       }

       public void addError(String message) {
         errors.add(message);
       }

       public ClientServerCompatibilityStatus build() {
         return new ClientServerCompatibilityStatus(warnings.build(), errors.build());
       }
     }

     public boolean isOk() {
       return warnings.isEmpty() && errors.isEmpty();
     }

     public List<String> getWarnings() {
       return warnings;
     }

     public List<String> getErrors() {
       return errors;
     }
   }

   private static void checkPriorityInRange(
       int priority,
       String optionName,
       PriorityCapabilities prCap,
       ClientServerCompatibilityStatus.Builder result) {
     if (priority != 0) {
       boolean found = false;
       StringBuilder rangeBuilder = new StringBuilder();
       for (PriorityRange pr : prCap.getPrioritiesList()) {
         rangeBuilder.append(String.format("%d-%d,", pr.getMinPriority(), pr.getMaxPriority()));
         if (pr.getMinPriority() <= priority && priority <= pr.getMaxPriority()) {
           found = true;
           break;
         }
       }
       if (!found) {
         String range = rangeBuilder.toString();
         if (!range.isEmpty()) {
           range = range.substring(0, range.length() - 1);
         }
         result.addError(
             String.format(
                 "--%s %d is outside of server supported range %s.", optionName, priority, range));
       }
     }
   }

   public enum ServerCapabilitiesRequirement {
     NONE,
     CACHE,
     EXECUTION,
     EXECUTION_AND_CACHE,
   }

   /** Compare the remote server capabilities with those requested by current execution. */
   public static ClientServerCompatibilityStatus checkClientServerCompatibility(
       ServerCapabilities capabilities,
       RemoteOptions remoteOptions,
       DigestFunction.Value digestFunction,
       ServerCapabilitiesRequirement requirement) {
     ClientServerCompatibilityStatus.Builder result = new ClientServerCompatibilityStatus.Builder();
     boolean shouldCheckExecutionCapabilities =
         (requirement == ServerCapabilitiesRequirement.EXECUTION
             || requirement == ServerCapabilitiesRequirement.EXECUTION_AND_CACHE);
     boolean shouldCheckCacheCapabilities =
         (requirement == ServerCapabilitiesRequirement.CACHE
             || requirement == ServerCapabilitiesRequirement.EXECUTION_AND_CACHE);
     if (!(shouldCheckCacheCapabilities || shouldCheckExecutionCapabilities)) {
       return result.build();
     }

     // Check API version.
     ApiVersion.ServerSupportedStatus st =
         ApiVersion.current.checkServerSupportedVersions(capabilities);
     if (st.isUnsupported()) {
       result.addError(st.getMessage());
     }
     if (st.isDeprecated()) {
       result.addWarning(st.getMessage());
     }

     if (shouldCheckExecutionCapabilities) {
       // Check remote execution is enabled.
       ExecutionCapabilities execCap = capabilities.getExecutionCapabilities();
       if (!execCap.getExecEnabled()) {
         result.addError(
             "Remote execution is not supported by the remote server, or the current "
                 + "account is not authorized to use remote execution.");
         return result.build(); // No point checking other execution fields.
       }

       // Check execution digest function.
       if (execCap.getDigestFunction() == DigestFunction.Value.UNKNOWN) {
         // Server side error -- this is not supposed to happen.
         result.addError("Remote server error: UNKNOWN execution digest function.");
       }
       if (execCap.getDigestFunction() != digestFunction) {
         result.addError(
             String.format(
                 "Cannot use hash function %s with remote execution. "
                     + "Server supported function is %s",
                 digestFunction, execCap.getDigestFunction()));
       }

       // Check execution priority is in the supported range.
       checkPriorityInRange(
           remoteOptions.remoteExecutionPriority,
           "remote_execution_priority",
           execCap.getExecutionPriorityCapabilities(),
           result);
     }

     if (shouldCheckCacheCapabilities) {
       // Check cache digest function.
       CacheCapabilities cacheCap = capabilities.getCacheCapabilities();
       if (!cacheCap.getDigestFunctionsList().contains(digestFunction)) {
         result.addError(
             String.format(
                 "Cannot use hash function %s with remote cache. "
                     + "Server supported functions are: %s",
                 digestFunction, cacheCap.getDigestFunctionsList()));
       }

       if (remoteOptions.remoteUploadLocalResults
           && !cacheCap.getActionCacheUpdateCapabilities().getUpdateEnabled()) {
         result.addWarning(
             "--remote_upload_local_results is set, but the remote cache does not support uploading "
                 + "action results or the current account is not authorized to write local results "
                 + "to the remote cache.");
       }

       if (remoteOptions.cacheCompression
           && !cacheCap.getSupportedCompressorsList().contains(Compressor.Value.ZSTD)) {
         result.addError(
             "--experimental_remote_cache_compression requested but remote does not support"
                 + " compression");
       }

       // Check result cache priority is in the supported range.
       checkPriorityInRange(
           remoteOptions.remoteResultCachePriority,
           "remote_result_cache_priority",
           cacheCap.getCachePriorityCapabilities(),
           result);
     }

     return result.build();
   }
 }
	// Copyright 2018 The Bazel Authors. All rights reserved.
	//
	// 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.google.devtools.build.lib.remote;

	import build.bazel.remote.execution.v2.CacheCapabilities;
	import build.bazel.remote.execution.v2.CapabilitiesGrpc;
	import build.bazel.remote.execution.v2.CapabilitiesGrpc.CapabilitiesBlockingStub;
	import build.bazel.remote.execution.v2.Compressor;
	import build.bazel.remote.execution.v2.DigestFunction;
	import build.bazel.remote.execution.v2.ExecutionCapabilities;
	import build.bazel.remote.execution.v2.GetCapabilitiesRequest;
	import build.bazel.remote.execution.v2.PriorityCapabilities;
	import build.bazel.remote.execution.v2.PriorityCapabilities.PriorityRange;
	import build.bazel.remote.execution.v2.RequestMetadata;
	import build.bazel.remote.execution.v2.ServerCapabilities;
	import com.google.common.collect.ImmutableList;
	import com.google.devtools.build.lib.remote.common.RemoteActionExecutionContext;
	import com.google.devtools.build.lib.remote.options.RemoteOptions;
	import com.google.devtools.build.lib.remote.util.TracingMetadataUtils;
	import io.grpc.CallCredentials;
	import io.grpc.Channel;
	import io.grpc.StatusRuntimeException;
	import java.io.IOException;
	import java.util.List;
	import java.util.concurrent.TimeUnit;
	import javax.annotation.Nullable;

	/** Fetches the ServerCapabilities of the remote execution/cache server. */
	class RemoteServerCapabilities {

	@Nullable private final String instanceName;
	private final ReferenceCountedChannel channel;
	@Nullable private final CallCredentials callCredentials;
	private final long callTimeoutSecs;
	private final RemoteRetrier retrier;

	public RemoteServerCapabilities(
	@Nullable String instanceName,
	ReferenceCountedChannel channel,
	@Nullable CallCredentials callCredentials,
	long callTimeoutSecs,
	RemoteRetrier retrier) {
	this.instanceName = instanceName;
	this.channel = channel;
	this.callCredentials = callCredentials;
	this.callTimeoutSecs = callTimeoutSecs;
	this.retrier = retrier;
	}

	private CapabilitiesBlockingStub capabilitiesBlockingStub(
	RemoteActionExecutionContext context, Channel channel) {
	return CapabilitiesGrpc.newBlockingStub(channel)
	.withInterceptors(
	TracingMetadataUtils.attachMetadataInterceptor(context.getRequestMetadata()))
	.withCallCredentials(callCredentials)
	.withDeadlineAfter(callTimeoutSecs, TimeUnit.SECONDS);
	}

	public ServerCapabilities get(String buildRequestId, String commandId)
	throws IOException, InterruptedException {
	RequestMetadata metadata =
	TracingMetadataUtils.buildMetadata(buildRequestId, commandId, "capabilities", null);
	RemoteActionExecutionContext context = RemoteActionExecutionContext.create(metadata);
	try {
	GetCapabilitiesRequest request =
	instanceName == null
	? GetCapabilitiesRequest.getDefaultInstance()
	: GetCapabilitiesRequest.newBuilder().setInstanceName(instanceName).build();
	return retrier.execute(
	() ->
	channel.withChannelBlocking(
	channel -> capabilitiesBlockingStub(context, channel).getCapabilities(request)));
	} catch (StatusRuntimeException e) {
	if (e.getCause() instanceof IOException) {
	throw (IOException) e.getCause();
	}
	throw new IOException(e);
	}
	}

	static class ClientServerCompatibilityStatus {

	private final List<String> warnings;
	private final List<String> errors;

	private ClientServerCompatibilityStatus(List<String> warnings, List<String> errors) {
	this.warnings = warnings;
	this.errors = errors;
	}

	static class Builder {
	private final ImmutableList.Builder<String> warnings = ImmutableList.builder();
	private final ImmutableList.Builder<String> errors = ImmutableList.builder();

	public void addWarning(String message) {
	warnings.add(message);
	}

	public void addError(String message) {
	errors.add(message);
	}

	public ClientServerCompatibilityStatus build() {
	return new ClientServerCompatibilityStatus(warnings.build(), errors.build());
	}
	}

	public boolean isOk() {
	return warnings.isEmpty() && errors.isEmpty();
	}

	public List<String> getWarnings() {
	return warnings;
	}

	public List<String> getErrors() {
	return errors;
	}
	}

	private static void checkPriorityInRange(
	int priority,
	String optionName,
	PriorityCapabilities prCap,
	ClientServerCompatibilityStatus.Builder result) {
	if (priority != 0) {
	boolean found = false;
	StringBuilder rangeBuilder = new StringBuilder();
	for (PriorityRange pr : prCap.getPrioritiesList()) {
	rangeBuilder.append(String.format("%d-%d,", pr.getMinPriority(), pr.getMaxPriority()));
	if (pr.getMinPriority() <= priority && priority <= pr.getMaxPriority()) {
	found = true;
	break;
	}
	}
	if (!found) {
	String range = rangeBuilder.toString();
	if (!range.isEmpty()) {
	range = range.substring(0, range.length() - 1);
	}
	result.addError(
	String.format(
	"--%s %d is outside of server supported range %s.", optionName, priority, range));
	}
	}
	}

	public enum ServerCapabilitiesRequirement {
	NONE,
	CACHE,
	EXECUTION,
	EXECUTION_AND_CACHE,
	}

	/** Compare the remote server capabilities with those requested by current execution. */
	public static ClientServerCompatibilityStatus checkClientServerCompatibility(
	ServerCapabilities capabilities,
	RemoteOptions remoteOptions,
	DigestFunction.Value digestFunction,
	ServerCapabilitiesRequirement requirement) {
	ClientServerCompatibilityStatus.Builder result = new ClientServerCompatibilityStatus.Builder();
	boolean shouldCheckExecutionCapabilities =
	(requirement == ServerCapabilitiesRequirement.EXECUTION
	\|\| requirement == ServerCapabilitiesRequirement.EXECUTION_AND_CACHE);
	boolean shouldCheckCacheCapabilities =
	(requirement == ServerCapabilitiesRequirement.CACHE
	\|\| requirement == ServerCapabilitiesRequirement.EXECUTION_AND_CACHE);
	if (!(shouldCheckCacheCapabilities \|\| shouldCheckExecutionCapabilities)) {
	return result.build();
	}

	// Check API version.
	ApiVersion.ServerSupportedStatus st =
	ApiVersion.current.checkServerSupportedVersions(capabilities);
	if (st.isUnsupported()) {
	result.addError(st.getMessage());
	}
	if (st.isDeprecated()) {
	result.addWarning(st.getMessage());
	}

	if (shouldCheckExecutionCapabilities) {
	// Check remote execution is enabled.
	ExecutionCapabilities execCap = capabilities.getExecutionCapabilities();
	if (!execCap.getExecEnabled()) {
	result.addError(
	"Remote execution is not supported by the remote server, or the current "
	+ "account is not authorized to use remote execution.");
	return result.build(); // No point checking other execution fields.
	}

	// Check execution digest function.
	if (execCap.getDigestFunction() == DigestFunction.Value.UNKNOWN) {
	// Server side error -- this is not supposed to happen.
	result.addError("Remote server error: UNKNOWN execution digest function.");
	}
	if (execCap.getDigestFunction() != digestFunction) {
	result.addError(
	String.format(
	"Cannot use hash function %s with remote execution. "
	+ "Server supported function is %s",
	digestFunction, execCap.getDigestFunction()));
	}

	// Check execution priority is in the supported range.
	checkPriorityInRange(
	remoteOptions.remoteExecutionPriority,
	"remote_execution_priority",
	execCap.getExecutionPriorityCapabilities(),
	result);
	}

	if (shouldCheckCacheCapabilities) {
	// Check cache digest function.
	CacheCapabilities cacheCap = capabilities.getCacheCapabilities();
	if (!cacheCap.getDigestFunctionsList().contains(digestFunction)) {
	result.addError(
	String.format(
	"Cannot use hash function %s with remote cache. "
	+ "Server supported functions are: %s",
	digestFunction, cacheCap.getDigestFunctionsList()));
	}

	if (remoteOptions.remoteUploadLocalResults
	&& !cacheCap.getActionCacheUpdateCapabilities().getUpdateEnabled()) {
	result.addWarning(
	"--remote_upload_local_results is set, but the remote cache does not support uploading "
	+ "action results or the current account is not authorized to write local results "
	+ "to the remote cache.");
	}

	if (remoteOptions.cacheCompression
	&& !cacheCap.getSupportedCompressorsList().contains(Compressor.Value.ZSTD)) {
	result.addError(
	"--experimental_remote_cache_compression requested but remote does not support"
	+ " compression");
	}

	// Check result cache priority is in the supported range.
	checkPriorityInRange(
	remoteOptions.remoteResultCachePriority,
	"remote_result_cache_priority",
	cacheCap.getCachePriorityCapabilities(),
	result);
	}

	return result.build();
	}
	}