private boolean opened;


    public LsaPolicyHandle ( DcerpcHandle handle, String server, int access ) throws IOException {
        this.handle = handle;
        if ( server == null ) {
            server = "\\\\";
        }
        MsrpcLsarOpenPolicy2 rpc = new MsrpcLsarOpenPolicy2(server, access, this);
        handle.sendrecv(rpc);
        if ( rpc.retval != 0 ) {

		// take this server down, return appropriate error.
		if opts.Maintenance {
			writeResponse(w, http.StatusPreconditionFailed, nil, mimeNone)
		} else {
			writeResponse(w, http.StatusServiceUnavailable, nil, mimeNone)
		}
		return
	}
	writeResponse(w, http.StatusOK, nil, mimeNone)
}

// ClusterReadCheckHandler returns if the server is ready for requests.

  @AfterEach fun tearDown() {
    httpClient.close()
  }

  @Test fun get(server: MockWebServer) {
    server.enqueue(
      MockResponse.Builder()
        .body("hello, Apache HttpClient 5.x")
        .build(),
    )

    val request = HttpGet(server.url("/").toUri())
    request.addHeader("Accept", "text/plain")

    httpClient.execute(request).use { response ->

        uses: actions/setup-java@8df1039502a15bceb9433410b1a100fbe190c53b # v4.5.0
        with:
          java-version: 21
          distribution: 'zulu'
          server-id: sonatype-nexus-snapshots
          server-username: CI_DEPLOY_USERNAME
          server-password: CI_DEPLOY_PASSWORD
          cache: 'maven'
      - name: 'Publish'
        env:
          CI_DEPLOY_USERNAME: ${{ secrets.CI_DEPLOY_USERNAME }}

 */

package jcifs.smb1.dcerpc.msrpc;

import jcifs.smb1.dcerpc.ndr.*;
import jcifs.smb1.smb1.*;

public class MsrpcDfsRootEnum extends netdfs.NetrDfsEnumEx {

    public MsrpcDfsRootEnum(String server) {
        super(server, 200, 0xFFFF, new netdfs.DfsEnumStruct(), new NdrLong(0));
        info.level = level;
        info.e = new netdfs.DfsEnumArray200();
        ptype = 0;
        flags = DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG;

 * future frames won't arrive on the stream ID.
 */
interface PushObserver {
  /**
   * Describes the request that the server intends to push a response for.
   *
   * @param streamId server-initiated stream ID: an even number.
   * @param requestHeaders minimally includes `:method`, `:scheme`, `:authority`,
   * and `:path`.
   */
  fun onRequest(
    streamId: Int,

                            "content": {"application/json": {"schema": {}}},
                        },
                        "500": {
                            "description": "Internal Server Error",
                            "content": {
                                "application/json": {
                                    "schema": {

class OkHttpClientTest {
  @RegisterExtension
  var platform = PlatformRule()

  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()

  private var server: MockWebServer? = null

  @BeforeEach fun setUp(server: MockWebServer?) {
    this.server = server
  }

  @AfterEach fun tearDown() {
    ProxySelector.setDefault(DEFAULT_PROXY_SELECTOR)
    CookieManager.setDefault(DEFAULT_COOKIE_HANDLER)

     * query. This might be the address of a specific host, a name server,
     * or a broadcast address.
     *
     * @param host
     *            the name to resolve
     * @param type
     *            the hex code of the name
     * @param scope
     *            the scope of the name
     * @param svr
     *            server to query
     * @return the resolved address

  command: server --console-address ":9001" http://minio{1...4}/data{1...2}
  expose:
    - "9000"
    - "9001"
  # environment:
    # MINIO_ROOT_USER: minioadmin
    # MINIO_ROOT_PASSWORD: minioadmin
  healthcheck:
    test: ["CMD", "mc", "ready", "local"]
    interval: 5s
    timeout: 5s
    retries: 5

# starts 4 docker containers running minio server instances.