java/com/google/gerrit/server/DeadlineChecker.java - gerrit - 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.google.gerrit.server;

 import static java.util.Comparator.comparing;
 import static java.util.Objects.requireNonNull;
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
 import static java.util.concurrent.TimeUnit.MINUTES;
 import static java.util.concurrent.TimeUnit.NANOSECONDS;
 import static java.util.stream.Collectors.toMap;

 import com.google.auto.value.AutoValue;
 import com.google.common.base.Strings;
 import com.google.common.collect.ImmutableList;
 import com.google.common.flogger.FluentLogger;
 import com.google.common.primitives.Longs;
 import com.google.gerrit.common.Nullable;
 import com.google.gerrit.server.cancellation.RequestStateProvider;
 import com.google.gerrit.server.config.ConfigUtil;
 import com.google.gerrit.server.config.GerritServerConfig;
 import com.google.gerrit.server.util.time.TimeUtil;
 import com.google.inject.assistedinject.Assisted;
 import com.google.inject.assistedinject.AssistedInject;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.TimeUnit;
 import java.util.function.Function;
 import org.eclipse.jgit.lib.Config;

 /**
  * {@link RequestStateProvider} that checks whether a client provided deadline is exceeded.
  *
  * <p>Should be registered at most once per request.
  */
 public class DeadlineChecker implements RequestStateProvider {
   private static final FluentLogger logger = FluentLogger.forEnclosingClass();

   private static String SECTION_DEADLINE = "deadline";

   /**
    * Creates a formatter that formats a timeout as {@code <TIMEOUT_NAME>=<TIMEOUT><TIME_UNIT>}.
    *
    * <p>If the timeout is 1 minute or greater, minutes is used as a time unit. Otherwise
    * milliseconds is just as a time unit.
    *
    * @param timeoutName the name of the timeout
    */
   public static Function<Long, String> getTimeoutFormatter(String timeoutName) {
     requireNonNull(timeoutName, "timeoutName");
     return timeout -> {
       String formattedTimeout = MILLISECONDS.convert(timeout, NANOSECONDS) + "ms";
       long timeoutInMinutes = MINUTES.convert(timeout, NANOSECONDS);
       if (timeoutInMinutes > 0) {
         formattedTimeout = timeoutInMinutes + "m";
       }
       return String.format("%s=%s", timeoutName, formattedTimeout);
     };
   }

   public interface Factory {
     DeadlineChecker create(RequestInfo requestInfo, @Nullable String clientProvidedTimeoutValue)
         throws InvalidDeadlineException;

     DeadlineChecker create(
         long start, RequestInfo requestInfo, @Nullable String clientProvidedTimeoutValue)
         throws InvalidDeadlineException;
   }

   private final CancellationMetrics cancellationsMetrics;

   /** The start time of the request in nanoseconds. */
   private final long start;

   private final RequestInfo requestInfo;
   private final RequestStateProvider.Reason cancellationReason;
   private final String timeoutName;

   /**
    * Timeout in nanoseconds after which the request should be aborted.
    *
    * <p>{@code 0} means that no timeout should be applied.
    */
   private final long timeout;

   /**
    * The deadline in nanoseconds after which a request should be aborted.
    *
    * <p>deadline = start + timeout
    *
    * <p>{@link Optional#empty()} if no timeout was set.
    */
   private final Optional<Long> deadline;

   /**
    * Matching server side deadlines that have been configured as as advisory.
    *
    * <p>If any of these deadlines is exceeded the request is not be aborted. Instead the {@code
    * cancellation/advisory_deadline_count} metric is incremented and a log is written.
    */
   private final Map<String, ServerDeadline> advisoryDeadlines;

   /**
    * Creates a {@link DeadlineChecker}.
    *
    * <p>No deadline is enforced if the client provided deadline value is {@code null} or {@code 0}.
    *
    * @param requestInfo the request that was received from a user
    * @param clientProvidedTimeoutValue the timeout value that the client provided, must represent a
    *     numerical time unit (e.g. "5m"), if no time unit is specified milliseconds are assumed, may
    *     be {@code null}
    * @throws InvalidDeadlineException thrown if the client provided deadline value cannot be parsed,
    *     e.g. because it uses a bad time unit
    */
   @AssistedInject
   DeadlineChecker(
       @GerritServerConfig Config serverConfig,
       CancellationMetrics cancellationsMetrics,
       @Assisted RequestInfo requestInfo,
       @Assisted @Nullable String clientProvidedTimeoutValue)
       throws InvalidDeadlineException {
     this(
         serverConfig,
         cancellationsMetrics,
         TimeUtil.nowNanos(),
         requestInfo,
         clientProvidedTimeoutValue);
   }

   /**
    * Creates a {@link DeadlineChecker}.
    *
    * <p>No deadline is enforced if the client provided deadline value is {@code null} or {@code 0}.
    *
    * @param start the start time of the request in nanoseconds
    * @param requestInfo the request that was received from a user
    * @param clientProvidedTimeoutValue the timeout value that the client provided, must represent a
    *     numerical time unit (e.g. "5m"), if no time unit is specified milliseconds are assumed, may
    *     be {@code null}
    * @throws InvalidDeadlineException thrown if the client provided deadline value cannot be parsed,
    *     e.g. because it uses a bad time unit
    */
   @AssistedInject
   DeadlineChecker(
       @GerritServerConfig Config serverConfig,
       CancellationMetrics cancellationsMetrics,
       @Assisted long start,
       @Assisted RequestInfo requestInfo,
       @Assisted @Nullable String clientProvidedTimeoutValue)
       throws InvalidDeadlineException {
     this.cancellationsMetrics = cancellationsMetrics;
     this.start = start;
     this.requestInfo = requestInfo;

     ImmutableList<RequestConfig> deadlineConfigs =
         RequestConfig.parseConfigs(serverConfig, SECTION_DEADLINE);
     advisoryDeadlines = getAdvisoryDeadlines(deadlineConfigs, requestInfo);
     Optional<ServerDeadline> serverSideDeadline =
         getServerSideDeadline(deadlineConfigs, requestInfo);
     Optional<Long> clientedProvidedTimeout = parseTimeout(clientProvidedTimeoutValue);
     logDeadlines(serverSideDeadline, clientedProvidedTimeout);

     this.cancellationReason =
         clientedProvidedTimeout.isPresent()
             ? RequestStateProvider.Reason.CLIENT_PROVIDED_DEADLINE_EXCEEDED
             : RequestStateProvider.Reason.SERVER_DEADLINE_EXCEEDED;
     this.timeoutName =
         clientedProvidedTimeout
             .map(clientTimeout -> "client.timeout")
             .orElse(
                 serverSideDeadline
                     .map(serverDeadline -> serverDeadline.id() + ".timeout")
                     .orElse("timeout"));
     this.timeout =
         clientedProvidedTimeout.orElse(serverSideDeadline.map(ServerDeadline::timeout).orElse(0L));
     this.deadline = timeout > 0 ? Optional.of(start + timeout) : Optional.empty();
   }

   private void logDeadlines(
       Optional<ServerDeadline> serverSideDeadline, Optional<Long> clientedProvidedTimeout) {
     if (serverSideDeadline.isPresent()) {
       if (clientedProvidedTimeout.isPresent()) {
         logger.atFine().log(
             "client provided deadline (timeout=%sms) overrides server deadline %s (timeout=%sms)",
             TimeUnit.MILLISECONDS.convert(clientedProvidedTimeout.get(), TimeUnit.NANOSECONDS),
             serverSideDeadline.get().id(),
             TimeUnit.MILLISECONDS.convert(
                 serverSideDeadline.get().timeout(), TimeUnit.NANOSECONDS));
       } else {
         logger.atFine().log(
             "applying server deadline %s (timeout = %sms)",
             serverSideDeadline.get().id(),
             TimeUnit.MILLISECONDS.convert(
                 serverSideDeadline.get().timeout(), TimeUnit.NANOSECONDS));
       }
     } else if (clientedProvidedTimeout.isPresent()) {
       logger.atFine().log(
           "applying client provided deadline (timeout = %sms)",
           TimeUnit.MILLISECONDS.convert(clientedProvidedTimeout.get(), TimeUnit.NANOSECONDS));
     }
   }

   private Optional<ServerDeadline> getServerSideDeadline(
       ImmutableList<RequestConfig> deadlineConfigs, RequestInfo requestInfo) {
     return deadlineConfigs.stream()
         .filter(deadlineConfig -> deadlineConfig.matches(requestInfo))
         .map(ServerDeadline::readFrom)
         .filter(ServerDeadline::hasTimeout)
         .filter(deadline -> !deadline.isAdvisory())
         // let the stricter deadline (the lower deadline) take precedence
         .sorted(comparing(ServerDeadline::timeout))
         .findFirst();
   }

   private Map<String, ServerDeadline> getAdvisoryDeadlines(
       ImmutableList<RequestConfig> deadlineConfigs, RequestInfo requestInfo) {
     return deadlineConfigs.stream()
         .filter(deadlineConfig -> deadlineConfig.matches(requestInfo))
         .map(ServerDeadline::readFrom)
         .filter(ServerDeadline::hasTimeout)
         .filter(ServerDeadline::isAdvisory)
         .collect(toMap(ServerDeadline::id, Function.identity()));
   }

   @Override
   public void checkIfCancelled(OnCancelled onCancelled) {
     long now = TimeUtil.nowNanos();

     Set<String> exceededAdvisoryDeadlines = new HashSet<>();
     advisoryDeadlines
         .values()
         .forEach(
             advisoryDeadline -> {
               if (now > start + advisoryDeadline.timeout()) {
                 exceededAdvisoryDeadlines.add(advisoryDeadline.id());
                 logger.atFine().log(
                     "advisory deadline exceeded (%s)",
                     getTimeoutFormatter(advisoryDeadline.id() + ".timeout")
                         .apply(advisoryDeadline.timeout()));
                 cancellationsMetrics.countAdvisoryDeadline(requestInfo, advisoryDeadline.id());
               }
             });
     // remove advisory deadlines which have already been reported as exceeded so that they don't get
     // reported again for this request
     exceededAdvisoryDeadlines.forEach(advisoryDeadlines::remove);

     if (deadline.isPresent() && now > deadline.get()) {
       onCancelled.onCancel(cancellationReason, getTimeoutFormatter(timeoutName).apply(timeout));
     }
   }

   /**
    * Parses the given timeout value.
    *
    * @param timeoutValue the timeout that should be parsed, must represent a numerical time unit
    *     (e.g. "5m"), if no time unit is specified minutes are assumed, may be {@code null}
    * @return the parsed timeout in nanoseconds, {@code 0} if no timeout should be applied
    * @throws InvalidDeadlineException thrown if the provided deadline value cannot be parsed, e.g.
    *     because it uses a bad time unit
    */
   private static Optional<Long> parseTimeout(@Nullable String timeoutValue)
       throws InvalidDeadlineException {
     if (Strings.isNullOrEmpty(timeoutValue)) {
       return Optional.empty();
     }

     if ("0".equals(timeoutValue)) {
       return Optional.of(0L);
     }

     // If no time unit was specified, assume milliseconds.
     if (Longs.tryParse(timeoutValue) != null) {
       throw new InvalidDeadlineException(String.format("Missing time unit: %s", timeoutValue));
     }

     try {
       long parsedTimeout =
           ConfigUtil.getTimeUnit(timeoutValue, /* defaultValue= */ -1, TimeUnit.NANOSECONDS);
       if (parsedTimeout == -1) {
         throw new InvalidDeadlineException(String.format("Invalid value: %s", timeoutValue));
       }
       return Optional.of(parsedTimeout);
     } catch (IllegalArgumentException e) {
       throw new InvalidDeadlineException(e.getMessage(), e);
     }
   }

   @AutoValue
   abstract static class ServerDeadline {
     abstract String id();

     abstract long timeout();

     abstract boolean isAdvisory();

     boolean hasTimeout() {
       return timeout() > 0;
     }

     static ServerDeadline readFrom(RequestConfig requestConfig) {
       String timeoutValue =
           requestConfig.cfg().getString(requestConfig.section(), requestConfig.id(), "timeout");
       boolean isAdvisory =
           requestConfig
               .cfg()
               .getBoolean(
                   requestConfig.section(),
                   requestConfig.id(),
                   "isAdvisory",
                   /* defaultValue= */ false);
       try {
         Optional<Long> timeout = parseTimeout(timeoutValue);
         return new AutoValue_DeadlineChecker_ServerDeadline(
             requestConfig.id(), timeout.orElse(0L), isAdvisory);
       } catch (InvalidDeadlineException e) {
         logger.atWarning().log(
             "Ignoring invalid deadline configuration %s.%s.timeout: %s",
             requestConfig.section(), requestConfig.id(), e.getMessage());
         return new AutoValue_DeadlineChecker_ServerDeadline(requestConfig.id(), 0, isAdvisory);
       }
     }
   }
 }
	// 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.google.gerrit.server;

	import static java.util.Comparator.comparing;
	import static java.util.Objects.requireNonNull;
	import static java.util.concurrent.TimeUnit.MILLISECONDS;
	import static java.util.concurrent.TimeUnit.MINUTES;
	import static java.util.concurrent.TimeUnit.NANOSECONDS;
	import static java.util.stream.Collectors.toMap;

	import com.google.auto.value.AutoValue;
	import com.google.common.base.Strings;
	import com.google.common.collect.ImmutableList;
	import com.google.common.flogger.FluentLogger;
	import com.google.common.primitives.Longs;
	import com.google.gerrit.common.Nullable;
	import com.google.gerrit.server.cancellation.RequestStateProvider;
	import com.google.gerrit.server.config.ConfigUtil;
	import com.google.gerrit.server.config.GerritServerConfig;
	import com.google.gerrit.server.util.time.TimeUtil;
	import com.google.inject.assistedinject.Assisted;
	import com.google.inject.assistedinject.AssistedInject;
	import java.util.HashSet;
	import java.util.Map;
	import java.util.Optional;
	import java.util.Set;
	import java.util.concurrent.TimeUnit;
	import java.util.function.Function;
	import org.eclipse.jgit.lib.Config;

	/**
	* {@link RequestStateProvider} that checks whether a client provided deadline is exceeded.
	*
	* <p>Should be registered at most once per request.
	*/
	public class DeadlineChecker implements RequestStateProvider {
	private static final FluentLogger logger = FluentLogger.forEnclosingClass();

	private static String SECTION_DEADLINE = "deadline";

	/**
	* Creates a formatter that formats a timeout as {@code <TIMEOUT_NAME>=<TIMEOUT><TIME_UNIT>}.
	*
	* <p>If the timeout is 1 minute or greater, minutes is used as a time unit. Otherwise
	* milliseconds is just as a time unit.
	*
	* @param timeoutName the name of the timeout
	*/
	public static Function<Long, String> getTimeoutFormatter(String timeoutName) {
	requireNonNull(timeoutName, "timeoutName");
	return timeout -> {
	String formattedTimeout = MILLISECONDS.convert(timeout, NANOSECONDS) + "ms";
	long timeoutInMinutes = MINUTES.convert(timeout, NANOSECONDS);
	if (timeoutInMinutes > 0) {
	formattedTimeout = timeoutInMinutes + "m";
	}
	return String.format("%s=%s", timeoutName, formattedTimeout);
	};
	}

	public interface Factory {
	DeadlineChecker create(RequestInfo requestInfo, @Nullable String clientProvidedTimeoutValue)
	throws InvalidDeadlineException;

	DeadlineChecker create(
	long start, RequestInfo requestInfo, @Nullable String clientProvidedTimeoutValue)
	throws InvalidDeadlineException;
	}

	private final CancellationMetrics cancellationsMetrics;

	/** The start time of the request in nanoseconds. */
	private final long start;

	private final RequestInfo requestInfo;
	private final RequestStateProvider.Reason cancellationReason;
	private final String timeoutName;

	/**
	* Timeout in nanoseconds after which the request should be aborted.
	*
	* <p>{@code 0} means that no timeout should be applied.
	*/
	private final long timeout;

	/**
	* The deadline in nanoseconds after which a request should be aborted.
	*
	* <p>deadline = start + timeout
	*
	* <p>{@link Optional#empty()} if no timeout was set.
	*/
	private final Optional<Long> deadline;

	/**
	* Matching server side deadlines that have been configured as as advisory.
	*
	* <p>If any of these deadlines is exceeded the request is not be aborted. Instead the {@code
	* cancellation/advisory_deadline_count} metric is incremented and a log is written.
	*/
	private final Map<String, ServerDeadline> advisoryDeadlines;

	/**
	* Creates a {@link DeadlineChecker}.
	*
	* <p>No deadline is enforced if the client provided deadline value is {@code null} or {@code 0}.
	*
	* @param requestInfo the request that was received from a user
	* @param clientProvidedTimeoutValue the timeout value that the client provided, must represent a
	* numerical time unit (e.g. "5m"), if no time unit is specified milliseconds are assumed, may
	* be {@code null}
	* @throws InvalidDeadlineException thrown if the client provided deadline value cannot be parsed,
	* e.g. because it uses a bad time unit
	*/
	@AssistedInject
	DeadlineChecker(
	@GerritServerConfig Config serverConfig,
	CancellationMetrics cancellationsMetrics,
	@Assisted RequestInfo requestInfo,
	@Assisted @Nullable String clientProvidedTimeoutValue)
	throws InvalidDeadlineException {
	this(
	serverConfig,
	cancellationsMetrics,
	TimeUtil.nowNanos(),
	requestInfo,
	clientProvidedTimeoutValue);
	}

	/**
	* Creates a {@link DeadlineChecker}.
	*
	* <p>No deadline is enforced if the client provided deadline value is {@code null} or {@code 0}.
	*
	* @param start the start time of the request in nanoseconds
	* @param requestInfo the request that was received from a user
	* @param clientProvidedTimeoutValue the timeout value that the client provided, must represent a
	* numerical time unit (e.g. "5m"), if no time unit is specified milliseconds are assumed, may
	* be {@code null}
	* @throws InvalidDeadlineException thrown if the client provided deadline value cannot be parsed,
	* e.g. because it uses a bad time unit
	*/
	@AssistedInject
	DeadlineChecker(
	@GerritServerConfig Config serverConfig,
	CancellationMetrics cancellationsMetrics,
	@Assisted long start,
	@Assisted RequestInfo requestInfo,
	@Assisted @Nullable String clientProvidedTimeoutValue)
	throws InvalidDeadlineException {
	this.cancellationsMetrics = cancellationsMetrics;
	this.start = start;
	this.requestInfo = requestInfo;

	ImmutableList<RequestConfig> deadlineConfigs =
	RequestConfig.parseConfigs(serverConfig, SECTION_DEADLINE);
	advisoryDeadlines = getAdvisoryDeadlines(deadlineConfigs, requestInfo);
	Optional<ServerDeadline> serverSideDeadline =
	getServerSideDeadline(deadlineConfigs, requestInfo);
	Optional<Long> clientedProvidedTimeout = parseTimeout(clientProvidedTimeoutValue);
	logDeadlines(serverSideDeadline, clientedProvidedTimeout);

	this.cancellationReason =
	clientedProvidedTimeout.isPresent()
	? RequestStateProvider.Reason.CLIENT_PROVIDED_DEADLINE_EXCEEDED
	: RequestStateProvider.Reason.SERVER_DEADLINE_EXCEEDED;
	this.timeoutName =
	clientedProvidedTimeout
	.map(clientTimeout -> "client.timeout")
	.orElse(
	serverSideDeadline
	.map(serverDeadline -> serverDeadline.id() + ".timeout")
	.orElse("timeout"));
	this.timeout =
	clientedProvidedTimeout.orElse(serverSideDeadline.map(ServerDeadline::timeout).orElse(0L));
	this.deadline = timeout > 0 ? Optional.of(start + timeout) : Optional.empty();
	}

	private void logDeadlines(
	Optional<ServerDeadline> serverSideDeadline, Optional<Long> clientedProvidedTimeout) {
	if (serverSideDeadline.isPresent()) {
	if (clientedProvidedTimeout.isPresent()) {
	logger.atFine().log(
	"client provided deadline (timeout=%sms) overrides server deadline %s (timeout=%sms)",
	TimeUnit.MILLISECONDS.convert(clientedProvidedTimeout.get(), TimeUnit.NANOSECONDS),
	serverSideDeadline.get().id(),
	TimeUnit.MILLISECONDS.convert(
	serverSideDeadline.get().timeout(), TimeUnit.NANOSECONDS));
	} else {
	logger.atFine().log(
	"applying server deadline %s (timeout = %sms)",
	serverSideDeadline.get().id(),
	TimeUnit.MILLISECONDS.convert(
	serverSideDeadline.get().timeout(), TimeUnit.NANOSECONDS));
	}
	} else if (clientedProvidedTimeout.isPresent()) {
	logger.atFine().log(
	"applying client provided deadline (timeout = %sms)",
	TimeUnit.MILLISECONDS.convert(clientedProvidedTimeout.get(), TimeUnit.NANOSECONDS));
	}
	}

	private Optional<ServerDeadline> getServerSideDeadline(
	ImmutableList<RequestConfig> deadlineConfigs, RequestInfo requestInfo) {
	return deadlineConfigs.stream()
	.filter(deadlineConfig -> deadlineConfig.matches(requestInfo))
	.map(ServerDeadline::readFrom)
	.filter(ServerDeadline::hasTimeout)
	.filter(deadline -> !deadline.isAdvisory())
	// let the stricter deadline (the lower deadline) take precedence
	.sorted(comparing(ServerDeadline::timeout))
	.findFirst();
	}

	private Map<String, ServerDeadline> getAdvisoryDeadlines(
	ImmutableList<RequestConfig> deadlineConfigs, RequestInfo requestInfo) {
	return deadlineConfigs.stream()
	.filter(deadlineConfig -> deadlineConfig.matches(requestInfo))
	.map(ServerDeadline::readFrom)
	.filter(ServerDeadline::hasTimeout)
	.filter(ServerDeadline::isAdvisory)
	.collect(toMap(ServerDeadline::id, Function.identity()));
	}

	@Override
	public void checkIfCancelled(OnCancelled onCancelled) {
	long now = TimeUtil.nowNanos();

	Set<String> exceededAdvisoryDeadlines = new HashSet<>();
	advisoryDeadlines
	.values()
	.forEach(
	advisoryDeadline -> {
	if (now > start + advisoryDeadline.timeout()) {
	exceededAdvisoryDeadlines.add(advisoryDeadline.id());
	logger.atFine().log(
	"advisory deadline exceeded (%s)",
	getTimeoutFormatter(advisoryDeadline.id() + ".timeout")
	.apply(advisoryDeadline.timeout()));
	cancellationsMetrics.countAdvisoryDeadline(requestInfo, advisoryDeadline.id());
	}
	});
	// remove advisory deadlines which have already been reported as exceeded so that they don't get
	// reported again for this request
	exceededAdvisoryDeadlines.forEach(advisoryDeadlines::remove);

	if (deadline.isPresent() && now > deadline.get()) {
	onCancelled.onCancel(cancellationReason, getTimeoutFormatter(timeoutName).apply(timeout));
	}
	}

	/**
	* Parses the given timeout value.
	*
	* @param timeoutValue the timeout that should be parsed, must represent a numerical time unit
	* (e.g. "5m"), if no time unit is specified minutes are assumed, may be {@code null}
	* @return the parsed timeout in nanoseconds, {@code 0} if no timeout should be applied
	* @throws InvalidDeadlineException thrown if the provided deadline value cannot be parsed, e.g.
	* because it uses a bad time unit
	*/
	private static Optional<Long> parseTimeout(@Nullable String timeoutValue)
	throws InvalidDeadlineException {
	if (Strings.isNullOrEmpty(timeoutValue)) {
	return Optional.empty();
	}

	if ("0".equals(timeoutValue)) {
	return Optional.of(0L);
	}

	// If no time unit was specified, assume milliseconds.
	if (Longs.tryParse(timeoutValue) != null) {
	throw new InvalidDeadlineException(String.format("Missing time unit: %s", timeoutValue));
	}

	try {
	long parsedTimeout =
	ConfigUtil.getTimeUnit(timeoutValue, /* defaultValue= */ -1, TimeUnit.NANOSECONDS);
	if (parsedTimeout == -1) {
	throw new InvalidDeadlineException(String.format("Invalid value: %s", timeoutValue));
	}
	return Optional.of(parsedTimeout);
	} catch (IllegalArgumentException e) {
	throw new InvalidDeadlineException(e.getMessage(), e);
	}
	}

	@AutoValue
	abstract static class ServerDeadline {
	abstract String id();

	abstract long timeout();

	abstract boolean isAdvisory();

	boolean hasTimeout() {
	return timeout() > 0;
	}

	static ServerDeadline readFrom(RequestConfig requestConfig) {
	String timeoutValue =
	requestConfig.cfg().getString(requestConfig.section(), requestConfig.id(), "timeout");
	boolean isAdvisory =
	requestConfig
	.cfg()
	.getBoolean(
	requestConfig.section(),
	requestConfig.id(),
	"isAdvisory",
	/* defaultValue= */ false);
	try {
	Optional<Long> timeout = parseTimeout(timeoutValue);
	return new AutoValue_DeadlineChecker_ServerDeadline(
	requestConfig.id(), timeout.orElse(0L), isAdvisory);
	} catch (InvalidDeadlineException e) {
	logger.atWarning().log(
	"Ignoring invalid deadline configuration %s.%s.timeout: %s",
	requestConfig.section(), requestConfig.id(), e.getMessage());
	return new AutoValue_DeadlineChecker_ServerDeadline(requestConfig.id(), 0, isAdvisory);
	}
	}
	}
	}