// 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.

    class ConstructorTests {

        @Test
        @DisplayName("Should create response with configuration")
        void testConstructor() {
            Smb2WriteResponse writeResponse = new Smb2WriteResponse(mockConfig);
            assertNotNull(writeResponse);
            // Note: getConfig() is protected, cannot test directly
        }

        @Test
        @DisplayName("Should initialize count to zero")

func writeSuccessResponseJSON(w http.ResponseWriter, response []byte) {
	writeResponse(w, http.StatusOK, response, mimeJSON)
}

// writeSuccessResponseXML writes success headers and response if any,
// with content-type set to `application/xml`.
func writeSuccessResponseXML(w http.ResponseWriter, response []byte) {
	writeResponse(w, http.StatusOK, response, mimeXML)
}

      }

      val response = dispatcher.dispatch(request)

      try {
        if (handleSocketEffect(peek.onResponseStart, socket, stream)) {
          return
        }

        writeResponse(stream, request, response)
        if (logger.isLoggable(Level.FINE)) {
          logger.fine(
            "${this@MockWebServer} received request: $request " +

	}
	switch errCode {
	case ErrSTSInternalError, ErrSTSUpstreamError:
		stsLogIf(ctx, err, logger.ErrorKind)
	}
	encodedErrorResponse := encodeResponse(stsErrorResponse)
	writeResponse(w, stsErr.HTTPStatusCode, encodedErrorResponse, mimeXML)
}

// STSError structure
type STSError struct {
	Code           string
	Description    string
	HTTPStatusCode int
}

			APIErrorResponse: getAPIErrorResponse(
				ctx,
				apiErr,
				r.URL.Path,
				w.Header().Get(xhttp.AmzRequestID),
				w.Header().Get(xhttp.AmzRequestHostID),
			),
		}

		writeResponse(w, apiErr.HTTPStatusCode, encodeResponse(errResp), mimeXML)
	}()

	opts, err = getOpts(ctx, r, bucket, object)
	if err != nil {
		switch vErr := err.(type) {
		case InvalidVersionID:

	case "201":
		resp := encodeResponse(PostResponse{
			Bucket:   objInfo.Bucket,
			Key:      objInfo.Name,
			ETag:     `"` + objInfo.ETag + `"`,
			Location: w.Header().Get(xhttp.Location),
		})
		writeResponse(w, http.StatusCreated, resp, mimeXML)
	case "200":
		writeSuccessResponseHeadersOnly(w)
	default:
		writeSuccessNoContent(w)
	}
}

// GetBucketPolicyStatusHandler -  Retrieves the policy status

				BucketName: bucket,
				Key:        object,
				Resource:   r.URL.Path,
				RequestID:  w.Header().Get(xhttp.AmzRequestID),
				HostID:     globalDeploymentID(),
			})
			writeResponse(w, serr.HTTPStatusCode(), encodedErrorResponse, mimeXML)
		} else {
			writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
		}
		return
	}
	defer s3Select.Close()

pkg net/rpc, type ServerCodec interface { Close, ReadRequestBody, ReadRequestHeader, WriteResponse }
pkg net/rpc, type ServerCodec interface, Close() error
pkg net/rpc, type ServerCodec interface, ReadRequestBody(interface{}) error
pkg net/rpc, type ServerCodec interface, ReadRequestHeader(*Request) error
pkg net/rpc, type ServerCodec interface, WriteResponse(*Response, interface{}) error
pkg net/rpc, type ServerError string