return client.endpoint.PoolIdx, client.endpoint.SetIdx, client.endpoint.DiskIdx
}

// Wrapper to restClient.CallWithMethod to handle network errors, in case of network error the connection is disconnected
// and a healthcheck routine gets invoked that would reconnect.
func (client *storageRESTClient) callGet(ctx context.Context, rpcMethod string, values url.Values, body io.Reader, length int64) (io.ReadCloser, error) {

      // create() would catch this, but give a confusing error message
      checkArgument(
          newLower.compareTo(newUpper) <= 0,
          "intersection is undefined for disconnected ranges %s and %s",
          this,
          connectedRange);

      // TODO(kevinb): all the precondition checks in the constructor are redundant...
      return create(newLower, newUpper);
    }
  }

    rangeMap.put(Range.closedOpen(7, 10), 2);
    rangeMap.put(Range.closedOpen(12, 15), 2);
    rangeMap.put(Range.closedOpen(18, 19), 3);

    rangeMap.putCoalescing(Range.closedOpen(-5, -4), 0); // disconnected
    rangeMap.putCoalescing(Range.closedOpen(-6, -5), 0); // lower than minimum

    rangeMap.putCoalescing(Range.closedOpen(2, 4), 1); // between
    rangeMap.putCoalescing(Range.closedOpen(9, 14), 0); // different value

			if contextCanceled(ctx) {
				w.WriteHeader(499)
				return
			}
			f.ServeHTTP(w, r)
		case <-r.Context().Done():
			globalHTTPStats.addRequestsInQueue(-1)
			// When the client disconnects before getting the S3 handler
			// status code response, set the status code to 499 so this request
			// will be properly audited and traced.
			w.WriteHeader(499)
		default:
			globalHTTPStats.addRequestsInQueue(-1)

            /* Tree thinks it is connected but transport disconnected
             * under it, reset tree to reflect the truth.
             */
            tree.treeDisconnect(true);
        }

        if( isConnected() ) {
            return;
        }

        getUncPath0();
        getFirstAddress();
        for ( ;; ) {
            try {
                doConnect();
                return;

      // create() would catch this, but give a confusing error message
      checkArgument(
          newLower.compareTo(newUpper) <= 0,
          "intersection is undefined for disconnected ranges %s and %s",
          this,
          connectedRange);

      // TODO(kevinb): all the precondition checks in the constructor are redundant...
      return create(newLower, newUpper);
    }
  }

            try {
                client.close();
            } catch (final OpenSearchException e) {
                logger.warn("Failed to close client.", e);
            }
            logger.info("Disconnected to {}", address);
        }
        connected = false;
    }

    @Override
    public ThreadPool threadPool() {
        return client.threadPool();
    }

    @Override

}

func (c *connMgr) LatestConn() *ZtunnelConnection {
	c.mu.Lock()
	defer c.mu.Unlock()
	return c.latestConn
}

func (c *connMgr) deleteConn(conn *ZtunnelConnection) {
	log.Debug("ztunnel disconnected")
	c.mu.Lock()
	defer c.mu.Unlock()
	delete(c.connectionSet, conn)
	if c.latestConn == conn {
		c.latestConn = nil
	}
	ztunnelConnected.RecordInt(int64(len(c.connectionSet)))
}

// this is used in tests

     * 
     * If enabled, SmbFile instances starting with their first use will hold a reference to their tree.
     * This means that trees/sessions/connections won't be idle-disconnected even if there are no other active
     * references (currently executing code, file descriptors).
     * 
     * Depending on the usage scenario, this may have some benefit as there won't be any delays for restablishing these

    addEdge(N1, N2, E12);
    assertThat(network.edges()).containsExactly(E12);
  }

  @Test
  public void edges_noEdges() {
    assertThat(network.edges()).isEmpty();
    // Network with no edges, given disconnected nodes
    addNode(N1);
    addNode(N2);
    assertThat(network.edges()).isEmpty();
  }

  @Test
  public void incidentEdges_oneEdge() {
    addEdge(N1, N2, E12);