configLock.RLock()
	r.Header.Set(xhttp.SubnetAPIKey, c.APIKey)
	configLock.RUnlock()
	r.Header.Set(xhttp.MinioDeploymentID, xhttp.GlobalDeploymentID)

	client := &http.Client{
		Timeout:   10 * time.Second,
		Transport: c.transport,
	}

	resp, err := client.Do(r)
	if err != nil {
		return "", err
	}
	defer xhttp.DrainBody(resp.Body)

	respBytes, err := io.ReadAll(io.LimitReader(resp.Body, respBodyLimit))

    // Resource state changed - may need to reconnect
    log.info("Resource change detected for: {}", notification.getResourceName());
    
    // Schedule reconnection attempt
    scheduleReconnection(1000);  // 1 second delay
}

private void handleClientMove(WitnessNotification notification) {
    // Server is asking client to move to different node
    log.info("Client move requested for resource: {}", notification.getResourceName());

        HotThreadMonitorTarget target2 = new HotThreadMonitorTarget();

        assertNotNull(target1, "First instance should not be null");
        assertNotNull(target2, "Second instance should not be null");
        assertNotSame(target1, target2, "Instances should be different objects");
    }

    @Test
    public void test_class_has_proper_annotations() {

 * #iterator()} method after the first, and whose iterator is always unmodifiable.
 *
 * <p>The {@code Iterable} specification does not make it absolutely clear what should happen on a
 * second invocation, so implementors have made various choices, including:
 *
 * <ul>
 *   <li>returning the same iterator again
 *   <li>throwing an exception of some kind

        void nullContextThrows() {
            assertThrows(NullPointerException.class, () -> new SmbNamedPipe("smb://server/IPC$/foo", 0, null));
        }

        @Test
        @DisplayName("Second constructor sets unshared based on flags")
        void secondCtorUnsharedFlagPath() throws Exception {
            // Arrange: include UNSHARED flag to exercise that branch

 * key. Since this is a default component, this will be a plain binding of ModelProcessor to
 * this implementation type; that is no hint/name.
 *
 * This leads to a second side effect in that any @Inject request for just ModelProcessor in
 * the same injector is immediately matched to this explicit binding, which means extensions

  STATUS=$? ;
  until [ $STATUS = 0 ]
  do
    ATTEMPTS=`expr $ATTEMPTS + 1` ;
    echo \"Failed attempts: $ATTEMPTS\" ;
    if [ $ATTEMPTS -gt $LIMIT ]; then
      exit 1 ;
    fi ;
    sleep 2 ; # 1 second intervals between attempts
    $MC_COMMAND ;
    STATUS=$? ;
  done ;
  set -e ; # reset `e` as active
  return 0
}

# checkUserExists ()

      j--;
    }
  }

  /** Returns {@code true} if the second list is a permutation of the first. */
  private static boolean isPermutation(List<?> first, List<?> second) {
    if (first.size() != second.size()) {
      return false;
    }
    Multiset<?> firstMultiset = HashMultiset.create(first);
    Multiset<?> secondMultiset = HashMultiset.create(second);
    return firstMultiset.equals(secondMultiset);
  }

            assertTrue(processHelper.isProcessRunning(sessionId));

            // Start second process with same session ID (should replace first)
            JobProcess jobProcess2 = processHelper.startProcess(sessionId, cmdList2, pbCall);
            assertNotNull(jobProcess2);

            // Wait for second process to be running
            Thread.sleep(100);

            // First decode
            response.decode(buffer1, 0, 50);
            byte[] data1 = response.getData();

            // Second decode should overwrite
            response.decode(buffer2, 10, 60);
            byte[] data2 = response.getData();

            // Verify second decode overwrote first
            assertEquals(60, data2.length);
            assertEquals((byte) 0x22, data2[0]);
        }
    }