How to use

Time

in

org.sonatype.goodies.common

ConnectionEvictionThread(final HttpClientConnectionManager connectionManager, final Time idleTime, final Time evictingDelayTime) {
 this(connectionManager, idleTime.toMillis(), evictingDelayTime.toMillis());
}

 @Override
 public Time deserialize(final JsonParser parser, final DeserializationContext context) throws IOException {
  return Time.seconds(parser.readValueAs(Long.class));
 }
}

 @Override
 public void serialize(final Time value, final JsonGenerator jgen, final SerializerProvider provider)
   throws IOException
 {
  jgen.writeNumber(value.toSecondsI());
 }
}

@Inject
public SharedHttpClientConnectionManager(
  final List<SSLContextSelector> sslContextSelectors,
  @Named("${nexus.httpclient.connectionpool.size:-20}") final int connectionPoolSize,
  @Named("${nexus.httpclient.connectionpool.maxSize:-200}") final int connectionPoolMaxSize,
  @Named("${nexus.httpclient.connectionpool.idleTime:-30s}") final Time connectionPoolIdleTime,
  @Named("${nexus.httpclient.connectionpool.evictingDelayTime:-5s}") final Time connectionPoolEvictingDelayTime,
  @Named("${nexus.httpclient.connectionpool.validateAfterInactivityTime:-2s}") final Time connectionPoolValidateAfterInactivityTime,
  @Named("${nexus.httpclient.connectionpool.default.requestTimeout:-20s}") final Time defaultSocketTimeout)
{
 super(
   new DefaultHttpClientConnectionOperator(createRegistry(sslContextSelectors), null, null),
   null,
   connectionPoolIdleTime.toMillis(),
   TimeUnit.MILLISECONDS
 );
 setMaxTotal(connectionPoolMaxSize);
 log.debug("Connection pool max-size: {}", connectionPoolMaxSize);
 setDefaultMaxPerRoute(Math.min(connectionPoolSize, connectionPoolMaxSize));
 log.debug("Connection pool size: {}", connectionPoolSize);
 this.connectionPoolIdleTime = checkNotNull(connectionPoolIdleTime);
 this.connectionPoolEvictingDelayTime = checkNotNull(connectionPoolEvictingDelayTime);
 setValidateAfterInactivity(connectionPoolValidateAfterInactivityTime.toMillisI());
 log.debug("Connection pool idle-time: {}, evicting delay: {}, validate after inactivity: {}",
   connectionPoolIdleTime, connectionPoolEvictingDelayTime, connectionPoolValidateAfterInactivityTime);
 setDefaultSocketConfig(SocketConfig.custom().setSoTimeout(defaultSocketTimeout.toMillisI()).build());
 log.debug("Default socket timeout {}", defaultSocketTimeout);
}

public BlockingHttpClient(final CloseableHttpClient delegate,
             final Config config,
             final RemoteConnectionStatusObserver statusObserver,
             final boolean repositoryOnline,
             final AutoBlockConfiguration autoBlockConfiguration)
{
 super(delegate);
 checkNotNull(config);
 this.statusObserver = checkNotNull(statusObserver);
 this.autoBlockConfiguration = checkNotNull(autoBlockConfiguration);
 
 blocked = config.blocked != null ? config.blocked : false;
 autoBlock = config.autoBlock != null ? config.autoBlock : false;
 if (repositoryOnline) {
  updateStatus(blocked ? BLOCKED : READY);
 }
 else {
  updateStatus(OFFLINE);
 }
 // TODO shall we use config.getConnectionConfig().getTimeout() * 2 as in NX2?
 autoBlockSequence = new FibonacciNumberSequence(Time.seconds(40).toMillis());
}

@Inject
public BrowseNodeEntityAdapter(final ComponentEntityAdapter componentEntityAdapter,
                final AssetEntityAdapter assetEntityAdapter,
                final BrowseNodeConfiguration configuration)
{
 super(DB_CLASS);
 this.assetEntityAdapter = checkNotNull(assetEntityAdapter);
 this.componentEntityAdapter = checkNotNull(componentEntityAdapter);
 this.timeoutMillis = configuration.getQueryTimeout().toMillisI();
}

@Override
protected void doConfigure(final Configuration configuration) throws Exception {
 config = facet(ConfigurationFacet.class).readSection(configuration, CONFIG_KEY, Config.class);
 cacheControllerHolder = new CacheControllerHolder(
   new CacheController(Time.minutes(config.contentMaxAge).toSecondsI(), null),
   new CacheController(Time.minutes(config.metadataMaxAge).toSecondsI(), null)
 );
 // normalize URL path to contain trailing slash
 if (!config.remoteUrl.getPath().endsWith("/")) {
  config.remoteUrl = config.remoteUrl.resolve(config.remoteUrl.getPath() + "/");
 }
 log.debug("Config: {}", config);
}

 @VisibleForTesting
 <K, V> javax.cache.Cache<K, V> maybeCreateCache(final String name) {
  if (Objects.equals(ACTIVE_SESSION_CACHE_NAME, name)) {
   // shiro's session cache needs to never expire:
   // http://shiro.apache.org/session-management.html#ehcache-session-cache-configuration
   return cacheHelperProvider.get().maybeCreateCache(name, EternalExpiryPolicy.factoryOf());
  }
  else {
   Time timeToLive = Optional.ofNullable(System.getProperty(name + ".timeToLive"))
     .map(Time::parse)
     .orElse(defaultTimeToLive.get());
   return cacheHelperProvider.get().maybeCreateCache(name,
     CreatedExpiryPolicy.factoryOf(new Duration(timeToLive.getUnit(), timeToLive.getValue())));
  }
 }
}

 @Override
 public void customize(final HttpClientPlan plan) {
  checkNotNull(plan);

  plan.setUserAgentBase(userAgentGenerator.generate());

  plan.getClient().setKeepAliveStrategy(new NexusConnectionKeepAliveStrategy(keepAliveDuration.toMillis()));
  plan.getClient().setRetryHandler(new StandardHttpRequestRetryHandler(2, false));

  plan.getConnection().setBufferSize(bufferSize.toBytesI());

  plan.getRequest().setConnectionRequestTimeout(connectionRequestTimeout.toMillisI());
  plan.getRequest().setCookieSpec(CookieSpecs.IGNORE_COOKIES);
  plan.getRequest().setExpectContinueEnabled(false);

  int requestTimeoutMillis = requestTimeout.toMillisI();
  plan.getSocket().setSoTimeout(requestTimeoutMillis);
  plan.getRequest().setConnectTimeout(requestTimeoutMillis);
  plan.getRequest().setSocketTimeout(requestTimeoutMillis);
 }
}

/**
 * Apply connection configuration to plan.
 */
private void apply(final ConnectionConfiguration connection, final HttpClientPlan plan) {
 if (connection.getTimeout() != null) {
  int timeout = connection.getTimeout().toMillisI();
  plan.getSocket().setSoTimeout(timeout);
  plan.getRequest().setConnectTimeout(timeout);
  plan.getRequest().setSocketTimeout(timeout);
 }
 if (connection.getMaximumRetries() != null) {
  plan.getClient().setRetryHandler(new StandardHttpRequestRetryHandler(connection.getMaximumRetries(), false));
 }
 if (connection.getUserAgentSuffix() != null) {
  checkState(plan.getUserAgentBase() != null, "Default User-Agent not set");
  plan.setUserAgentSuffix(connection.getUserAgentSuffix());
 }
 if (Boolean.TRUE.equals(connection.getUseTrustStore())) {
  plan.getAttributes().put(SSLContextSelector.USE_TRUST_STORE, Boolean.TRUE);
 }
 if (Boolean.TRUE.equals(connection.getEnableCircularRedirects())) {
  plan.getRequest().setCircularRedirectsAllowed(true);
 }
 if (Boolean.TRUE.equals(connection.getEnableCookies())) {
  plan.getRequest().setCookieSpec(CookieSpecs.DEFAULT);
 }
}

@VisibleForTesting
protected boolean isTokenExpired(final long now, final Entry<UserAuthToken, Long> entry) {
 long diff = now - entry.getValue();
 return diff > expireAfter.toMillis();
}

@VisibleForTesting
public AuthTicketCache() {
 this(Time.seconds(2));
}

public static Pause pause(Time time) {
 return new Pause(time.toMillis());
}