org.jboss.netty.handler.codec.http.HttpMethod Java Examples

public HttpServerRequestHandler() {
  	super();    	
  	
  	// handlers
  	registerHandler(HttpMethod.GET, "/", new WelcomeHandler());	
registerHandler(HttpMethod.GET, "/hls/*/*", new HlsLiveHandler());
registerHandler(HttpMethod.GET, "/hls/vod/*/*", new HlsVodHandler());

registerHandler(HttpMethod.POST, "/hls/manage", new HlsManageHandler());
registerHandler(HttpMethod.GET, "/hls/streams", new HlsStreamsHandler());

//  login & logout ...
registerHandler(HttpMethod.GET, "/auth", new AuthHandler());	

registerHandler(HttpMethod.POST, "/api/dns/update", new HttpServerTest.TestHandler());

// filters
registerFilter(new HlsTrafficFilter(), Type.HLS);		
registerFilter(new AuthCheckFilter(), Type.VM, Type.API);		
  }
 

@Override
public Method method() {
    HttpMethod httpMethod = request.getMethod();
    if (httpMethod == HttpMethod.GET)
        return Method.GET;

    if (httpMethod == HttpMethod.POST)
        return Method.POST;

    if (httpMethod == HttpMethod.PUT)
        return Method.PUT;

    if (httpMethod == HttpMethod.DELETE)
        return Method.DELETE;

    if (httpMethod == HttpMethod.HEAD) {
        return Method.HEAD;
    }

    if (httpMethod == HttpMethod.OPTIONS) {
        return Method.OPTIONS;
    }

    return Method.GET;
}
 

private void registerHandler(HttpMethod method, String path, IRequestHandler handler) {
	if (method == HttpMethod.GET) {
		getHandlers.insert(path, handler);

	} else if (method == HttpMethod.POST) {
		postHandlers.insert(path, handler);

	} else {
		throw new RuntimeException("HttpMethod is not supported");
	}
}
 

public HttpRequest createMockHttpRequest() {
  HttpRequest mockHttpRequest = mock(HttpRequest.class);
  Mockito.doReturn(HttpMethod.GET).when(mockHttpRequest).getMethod();
  Mockito.doReturn(new DefaultHttpHeaders()).when(mockHttpRequest).headers();
  Mockito.doAnswer(new Answer() {
    @Override
    public Object answer(InvocationOnMock invocation) throws Throwable {
      String uri = "/mapOutput?job=job_12345_1&dag=1&reduce=1";
      for (int i = 0; i < 100; i++)
        uri = uri.concat("&map=attempt_12345_1_m_" + i + "_0");
      return uri;
    }
  }).when(mockHttpRequest).getUri();
  return mockHttpRequest;
}
 

@Override
protected HttpRequest createHttpRequest(URL url, ClusterUpdateSettingsRequest request) throws IOException {
    XContentBuilder builder = jsonBuilder();
    builder.startObject().startObject("persistent");
    request.persistentSettings().toXContent(builder, ToXContent.EMPTY_PARAMS);
    builder.endObject();
    builder.startObject("transient");
    request.transientSettings().toXContent(builder, ToXContent.EMPTY_PARAMS);
    builder.endObject().endObject();
    return newRequest(HttpMethod.PUT, url, "/_cluster/settings", builder.string());
}
 

@Override
protected HttpRequest createHttpRequest(URL url, UpdateSettingsRequest request) throws IOException {
    XContentBuilder builder = jsonBuilder();
    builder.startObject();
    request.settings().toXContent(builder, ToXContent.EMPTY_PARAMS);
    builder.endObject();
    String index = request.indices() != null ? "/" + String.join(",", request.indices()) : "" ;
    return newRequest(HttpMethod.PUT, url, index + "/_settings", builder.string());
}
 

protected HttpRequest newRequest(HttpMethod method, URL url, String path, ChannelBuffer buffer) {
    HttpRequest request = new DefaultHttpRequest(HttpVersion.HTTP_1_1, method, path);
    request.headers().add(HttpHeaders.Names.HOST, url.getHost());
    request.headers().add(HttpHeaders.Names.CONNECTION, HttpHeaders.Values.CLOSE);
    request.headers().add(HttpHeaders.Names.ACCEPT_ENCODING, HttpHeaders.Values.GZIP);
    if (buffer != null) {
        request.setContent(buffer);
        int length = request.getContent().readableBytes();
        request.headers().add(HttpHeaders.Names.CONTENT_TYPE, "application/json");
        request.headers().add(HttpHeaders.Names.CONTENT_LENGTH, length);
    }
    return request;
}
 

public static void main(String[] args) {
	RestExpress server = new RestExpress().setName("Echo");

	server.uri("/echo", new RestfulHandler()).method(HttpMethod.GET)
			.noSerialization();

	server.bind(8000);
	server.awaitShutdown();
}
 

@Override
public void messageReceived(final ChannelHandlerContext ctx, final MessageEvent evt) throws Exception {
	final HttpRequest req = (HttpRequest)evt.getMessage();
	final HttpMethod method = req.getMethod();

	LOG.info("messageReceived : HttpMethod: " + method);
	
	if (RaopRtspMethods.ANNOUNCE.equals(method)) {
		announceReceived(ctx, req);
		return;
	}
	else if (RaopRtspMethods.SETUP.equals(method)) {
		setupReceived(ctx, req);
		return;
	}
	else if (RaopRtspMethods.RECORD.equals(method)) {
		recordReceived(ctx, req);
		return;
	}
	else if (RaopRtspMethods.FLUSH.equals(method)) {
		flushReceived(ctx, req);
		return;
	}
	else if (RaopRtspMethods.TEARDOWN.equals(method)) {
		teardownReceived(ctx, req);
		return;
	}
	else if (RaopRtspMethods.SET_PARAMETER.equals(method)) {
		setParameterReceived(ctx, req);
		return;
	}
	else if (RaopRtspMethods.GET_PARAMETER.equals(method)) {
		getParameterReceived(ctx, req);
		return;
	}

	super.messageReceived(ctx, evt);
}
 

public WrapFileClientHandler(String host, URI uri, String userName,
		String pwd) {
	this.host = host;
	this.uri = uri;
	this.userName = userName;
	this.pwd = pwd;
	this.request = new DefaultHttpRequest(HttpVersion.HTTP_1_1,
			HttpMethod.POST, uri.toASCIIString());
	setHeaderDatas();
}
 

@Override
public void execute(final TSDB tsdb, final HttpRpcPluginQuery query) throws IOException {
  // only accept GET/POST for now
  if (query.request().getMethod() != HttpMethod.GET && 
      query.request().getMethod() != HttpMethod.POST) {
    throw new BadRequestException(HttpResponseStatus.METHOD_NOT_ALLOWED, 
        "Method not allowed", "The HTTP method [" + query.method().getName() +
        "] is not permitted for this endpoint");
  }
  
  final String[] uri = query.explodePath();
  final String endpoint = uri.length > 1 ? uri[2].toLowerCase() : "";
  
  if ("version".equals(endpoint)) {
    handleVersion(query);
  } else if ("rate".equals(endpoint)) {
    handleRate(query);
  } else if ("namespace".equals(endpoint)) {
    handlePerNamespaceStats(query);
  } else if ("perthread".equals(endpoint)) {
    handlePerThreadStats(query);
  } else {
    throw new BadRequestException(HttpResponseStatus.NOT_IMPLEMENTED, 
        "Hello. You have reached an API that has been disconnected. "
        + "Please call again.");
  }
}
 

private CorsConfig buildCorsConfig(Settings settings) {
    if (settings.getAsBoolean(SETTING_CORS_ENABLED, false) == false) {
        return CorsConfigBuilder.forOrigins().disable().build();
    }
    String origin = settings.get(SETTING_CORS_ALLOW_ORIGIN);
    final CorsConfigBuilder builder;
    if (Strings.isNullOrEmpty(origin)) {
        builder = CorsConfigBuilder.forOrigins();
    } else if (origin.equals(ANY_ORIGIN)) {
        builder = CorsConfigBuilder.forAnyOrigin();
    } else {
        Pattern p = RestUtils.checkCorsSettingForRegex(origin);
        if (p == null) {
            builder = CorsConfigBuilder.forOrigins(RestUtils.corsSettingAsArray(origin));
        } else {
            builder = CorsConfigBuilder.forPattern(p);
        }
    }
    if (settings.getAsBoolean(SETTING_CORS_ALLOW_CREDENTIALS, false)) {
        builder.allowCredentials();
    }
    String[] strMethods = settings.getAsArray(SETTING_CORS_ALLOW_METHODS, DEFAULT_CORS_METHODS);
    HttpMethod[] methods = new HttpMethod[strMethods.length];
    for (int i = 0; i < methods.length; i++) {
        methods[i] = HttpMethod.valueOf(strMethods[i]);
    }
    return builder.allowedRequestMethods(methods)
                  .maxAge(settings.getAsInt(SETTING_CORS_MAX_AGE, DEFAULT_CORS_MAX_AGE))
                  .allowedRequestHeaders(settings.getAsArray(SETTING_CORS_ALLOW_HEADERS, DEFAULT_CORS_HEADERS))
                  .shortCircuit()
                  .build();
}
 

private void setAllowMethods(final HttpResponse response) {
    Set<String> strMethods = new HashSet<>();
    for (HttpMethod method : config.allowedRequestMethods()) {
        strMethods.add(method.getName().trim());
    }
    response.headers().set(ACCESS_CONTROL_ALLOW_METHODS, strMethods);
}
 

protected HttpRequest newPostRequest(URL url, String path, CharSequence content) {
    return newRequest(HttpMethod.POST, url, path, content);
}
 

private IRequestHandler getHandler(HttpRequest request) {
  	
  	IRequestHandler handler = null;
  	
  	//解析QueryString    	
String uriString = request.getUri();

//获取Path
String path = null;
  	int pathEndPos = uriString.indexOf('?');
if (pathEndPos < 0) {
	path = uriString;
} else {
	path = uriString.substring(0, pathEndPos);	
}

// 获取参数
Map<String, String> parameters = new HashMap<String, String>();
if (uriString.startsWith("?")) {
	uriString = uriString.substring(1, uriString.length());
}
String[] querys = uriString.split("&");
for (String query : querys) {
	String[] pair = query.split("=");
	if (pair.length == 2) {								
		try {
			parameters.put(URLDecoder.decode(pair[0], "UTF8"), URLDecoder.decode(pair[1],"UTF8"));
		} catch (UnsupportedEncodingException e) {
			parameters.put(pair[0], pair[1]);
		}
	}
}

      HttpMethod method = request.getMethod();
      if (method == HttpMethod.GET) {
      	handler = getHandlers.retrieve(path, parameters);
      	
      } else if (method == HttpMethod.POST) {
          	handler = postHandlers.retrieve(path, parameters);
      } 
      return handler;
  }
 

@Override
public HttpMethod getMethod() {
    return request.getMethod();
}
 

@Override
protected HttpRequest createHttpRequest(URL url, SearchRequest request) throws IOException {
    String index = request.indices() != null ? "/" + String.join(",", request.indices()) : "";
    return newRequest(HttpMethod.POST, url, index + "/_search", request.extraSource());
}
 

private static boolean isPreflightRequest(final HttpRequest request) {
    final HttpHeaders headers = request.headers();
    return request.getMethod().equals(HttpMethod.OPTIONS) &&
               headers.contains(HttpHeaders.Names.ORIGIN) &&
               headers.contains(HttpHeaders.Names.ACCESS_CONTROL_REQUEST_METHOD);
}
 

protected HttpRequest newRequest(HttpMethod method, URL url, String path, BytesReference content) {
    return newRequest(method, url, path, content != null ? ChannelBuffers.copiedBuffer(content.toBytes()) : null);
}
 

protected HttpRequest newRequest(HttpMethod method, URL url, String path, CharSequence content) {
    return newRequest(method, url, path, content != null ? ChannelBuffers.copiedBuffer(content, CharsetUtil.UTF_8) : null);
}
 

protected HttpRequest newGetRequest(URL url, String path, CharSequence content) {
    return newRequest(HttpMethod.GET, url, path, content);
}
 

private final static HttpRequest buildRequest(AsyncHttpClientConfig config,Request request, URI uri) throws IOException{
	return construct(config, request, new HttpMethod(request.getType().toString()), uri);
}
 

/**
 * Make an HTTP request.
 */
private <T> PubsubFuture<T> request(final String operation, final HttpMethod method, final String path,
                                    final ResponseReader<T> responseReader) {
  return request(operation, method, path, NO_PAYLOAD, responseReader);
}
 

/**
 * Make a DELETE request.
 */
private <T> PubsubFuture<T> delete(final String operation, final String path, final ResponseReader<T> responseReader) {
  return request(operation, HttpMethod.DELETE, path, responseReader);
}
 

/**
 * Make a PUT request.
 */
private <T> PubsubFuture<T> put(final String operation, final String path, final Object payload,
                                final ResponseReader<T> responseReader) {
  return request(operation, HttpMethod.PUT, path, payload, responseReader);
}
 

/**
 * Make a POST request.
 */
private <T> PubsubFuture<T> post(final String operation, final String path, final Object payload,
                                 final ResponseReader<T> responseReader) {
  return request(operation, HttpMethod.POST, path, payload, responseReader);
}
 

/**
 * Make a GET request.
 */
private <T> PubsubFuture<T> get(final String operation, final String path, final ResponseReader<T> responseReader) {
  return request(operation, HttpMethod.GET, path, responseReader);
}
 

/**
 * Specifies the allowed set of HTTP Request Methods that should be returned in the
 * CORS 'Access-Control-Request-Method' response header.
 *
 * @param methods the {@link HttpMethod}s that should be allowed.
 * @return {@link CorsConfigBuilder} to support method chaining.
 */
public CorsConfigBuilder allowedRequestMethods(final HttpMethod... methods) {
    requestMethods.addAll(Arrays.asList(methods));
    return this;
}
 

/**
 * Returns the method of this request.
 */
HttpMethod getMethod();
 

/**
 * Returns the allowed set of Request Methods. The Http methods that should be returned in the
 * CORS 'Access-Control-Request-Method' response header.
 *
 * @return {@code Set} of {@link HttpMethod}s that represent the allowed Request Methods.
 */
public Set<HttpMethod> allowedRequestMethods() {
    return Collections.unmodifiableSet(allowedRequestMethods);
}