* limitations under the License.
 */

package org.gradle.internal.remote.internal.hub;

import org.gradle.internal.serialize.*;
import org.gradle.internal.dispatch.MethodInvocation;

import java.io.IOException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

		w.Header().Set("Access-Control-Allow-Credentials", allowCredentials)

		// Stop here if its a preflight OPTIONS request
		if req.Method == "OPTIONS" {
			w.WriteHeader(http.StatusNoContent)
			return
		}

		// Dispatch to the next handler
		handler.ServeHTTP(w, req)
	})
}

// isOriginAllowed returns true if the given origin header in the
// request is allowed CORS.
//
// From https://www.rfc-editor.org/rfc/rfc6454#page-13

import java.io.IOException
import okhttp3.Protocol
import okio.BufferedSource

/**
 * [HTTP/2][Protocol.HTTP_2] only. Processes server-initiated HTTP requests on the client.
 * Implementations must quickly dispatch callbacks to avoid creating a bottleneck.
 *
 * While [onReset] may occur at any time, the following callbacks are expected in order,
 * correlated by stream ID.
 *
 *  * [onRequest]
 *  * [onHeaders] (unless canceled)

            }

            @Override
            public void handle(String target, HttpServletRequest request, HttpServletResponse response, int dispatch)
                    throws java.io.IOException, ServletException {

                if (!isMultipartRequest(request) || !request.getMethod().equals(HttpMethods.POST)) {

    MockWebServer server = new MockWebServer();
    server.useHttps(sslContext.getSocketFactory(), false);
    server.setDispatcher(this);
    server.start(port);
  }

  @Override public MockResponse dispatch(RecordedRequest request) {
    String path = request.getPath();
    try {
      if (!path.startsWith("/") || path.contains("..")) throw new FileNotFoundException();

      File file = new File(root + path);

                try {
                    final ReportStatus statusCommand = new ReportStatus(idGenerator.generateId(), daemon.getToken());
                    final Status status = reportStatusDispatcher.dispatch(connection, statusCommand);
                    if (status != null) {
                        statuses.add(status);
                    } else { // Handle failure

Calls can be canceled from any thread. This will fail the call if it hasn’t yet completed! Code that is writing the request body or reading the response body will suffer an `IOException` when its call is canceled.

## Dispatch

For synchronous calls, you bring your own thread and are responsible for managing how many simultaneous requests you make. Too many simultaneous connections wastes resources; too few harms latency.

	Glob(pattern string) ([]string, error)
	Open(name string) (*os.File, error)
	OpenFile(name string, flag int, perm os.FileMode) (*os.File, error)
	Rename(oldpath, newpath string) error
}

// RealOS is used to dispatch the real system level operations.
type RealOS struct{}

// MkdirAll will call os.MkdirAll to create a directory.
func (RealOS) MkdirAll(path string, perm os.FileMode) error {
	return os.MkdirAll(path, perm)
}

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.remote.internal.hub

import org.gradle.internal.dispatch.MethodInvocation
import org.gradle.internal.serialize.kryo.KryoBackedDecoder
import org.gradle.internal.serialize.kryo.KryoBackedEncoder
import spock.lang.Specification

  const string& name() const { return name_; }
  const std::vector<Operation>& control_deps() const { return control_deps_; }

 private:
  friend class Scope;

  // Tag types to choose the constructor to dispatch.
  struct Tags {
    enum class ScopeName;
    enum class OpName;
    enum class ControlDeps;
    enum class Device;
    enum class SingleUseScope;
    enum class ExitOnError;
    enum class KernelLabel;