}

    /**
     * Gets the network name.
     *
     * @return the network name
     */
    public String getNetName() {
        return netName;
    }

    /**
     * Sets the share name to monitor.
     *
     * @param shareName the share name
     */
    public void setShareName(String shareName) {
        this.shareName = shareName;
    }

    /**
     * Gets the share name.
     *

Events
======

Events allow you to capture metrics on your application’s HTTP calls. Use events to monitor:

 * The size and frequency of the HTTP calls your application makes. If you’re making too many calls, or your calls are too large, you should know about it!
 * The performance of these calls on the underlying network. If the network’s performance isn’t sufficient, you need to either improve the network or use less of it.

### EventListener

Interceptors
============

Interceptors are a powerful mechanism that can monitor, rewrite, and retry calls. Here's a simple interceptor that logs the outgoing request and the incoming response.

```java
class LoggingInterceptor implements Interceptor {
  @Override public Response intercept(Interceptor.Chain chain) throws IOException {
    Request request = chain.request();

    long t1 = System.nanoTime();

   */
  public void callAndAssertWaits(String methodName, Object conditionLikeObject) throws Exception {
    checkNotNull(methodName);
    checkNotNull(conditionLikeObject);
    // TODO: Restore the following line when Monitor.hasWaiters() no longer acquires the lock.
    // assertEquals(false, invokeMethod("hasWaiters", conditionLikeObject));
    sendRequest(methodName, conditionLikeObject);
    Thread.sleep(DUE_DILIGENCE_MILLIS);

          // because the service does not monitor the state of the future so if the exception is not
          // caught and forwarded to the service the task would stop executing but the service would
          // have no idea.
          // TODO(lukes): consider building everything in terms of ListenableScheduledFuture then
          // the AbstractService could monitor the future directly. Rescheduling is still hard...

import java.io.IOException
import java.net.InetAddress
import java.net.InetSocketAddress
import java.net.ProtocolException
import java.net.Proxy

/**
 * Listener for metrics events. Extend this class to monitor the quantity, size, and duration of
 * your application's HTTP calls.
 *
 * All start/connect/acquire events will eventually receive a matching end/release event, either

          // because the service does not monitor the state of the future so if the exception is not
          // caught and forwarded to the service the task would stop executing but the service would
          // have no idea.
          // TODO(lukes): consider building everything in terms of ListenableScheduledFuture then
          // the AbstractService could monitor the future directly. Rescheduling is still hard...

     * Get the value for the key 'crawler.system.monitor.interval'. <br>
     * The value is, e.g. 60 <br>
     * comment: Interval (seconds) for system monitor during crawling.
     * @return The value of found property. (NotNull: if not found, exception but basically no way)
     */
    String getCrawlerSystemMonitorInterval();

    /**
     * Get the value for the key 'crawler.system.monitor.interval' as {@link Integer}. <br>

Directory leasing extends the SMB3 lease concept to directories, enabling client-side caching of directory metadata and change notifications. This significantly improves performance for applications that frequently enumerate directories or monitor directory changes.

## 2. Protocol Specification Reference

- **MS-SMB2 Section 2.2.13.2.12**: SMB2_CREATE_REQUEST_LEASE_V2 for directories
- **MS-SMB2 Section 2.2.14.2.12**: SMB2_CREATE_RESPONSE_LEASE_V2 for directories  

    running SSLv3, you must manually configure your own `ConnectionSpec`.

 *  **OkHttp now offers interceptors.** Interceptors are a powerful mechanism
    that can monitor, rewrite, and retry calls. The [interceptors doc][interceptors] is a full
    introduction to this new API.

 *  New: APIs to iterate and selectively clear the response cache.
 *  New: Support for SOCKS proxies.