/** Whether the request method is post, if yes return true, else return false */
@Override
public boolean isPostMethod() {
HttpMethod httpMethod = getMethod();
if (httpMethod.equals(HttpMethod.POST) || httpMethod.equals(HttpMethod.PUT)) {
return true;
}
return false;
}
public void sendRequest(MetaInfo meta) {
System.out.println(Thread.currentThread().getId() + " start sendRequest");
URI uri = null;
try {
System.out.println(meta.getParams());
uri = new URI(meta.getUrl());
} catch (URISyntaxException e) {
e.printStackTrace(); // To change body of catch statement use File | Settings | File
// Templates.
}
String host = uri.getHost();
int port = 80;
HttpRequest request =
new DefaultHttpRequest(
HttpVersion.HTTP_1_1, HttpMethod.valueOf(meta.getMethod()), uri.toASCIIString());
meta.buildHttpRequestHeader(request);
ChannelFuture future = bootstrap.connect(new InetSocketAddress(host, port));
Channel channel = future.getChannel();
channel.getPipeline().addLast("handler", new DownloaderHandler());
GlobalVar.metaInfoVar.set(channel, meta);
future.addListener(new ConnectOk(request));
channel.getCloseFuture().awaitUninterruptibly().addListener(new ConnectClose());
System.out.println(Thread.currentThread().getId() + " end sendRequest");
}
private HttpClientRequest(
final HttpClient client,
final String method,
final String uri,
final Handler<HttpClientResponse> respHandler,
final Context context,
final Thread th,
final boolean raw) {
this.client = client;
this.request = new DefaultHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.valueOf(method), uri);
this.chunked = false;
this.respHandler = respHandler;
this.context = context;
this.th = th;
this.raw = raw;
}
/**
* Creates the {@link HttpMethod} to use to call the remote server, often either its GET or POST.
*
* @param message the Camel message
* @return the created method
*/
public static HttpMethod createMethod(Message message, boolean hasPayload) {
// use header first
HttpMethod m = message.getHeader(Exchange.HTTP_METHOD, HttpMethod.class);
if (m != null) {
return m;
}
String name = message.getHeader(Exchange.HTTP_METHOD, String.class);
if (name != null) {
return HttpMethod.valueOf(name);
}
if (hasPayload) {
// use POST if we have payload
return HttpMethod.POST;
} else {
// fallback to GET
return HttpMethod.GET;
}
}
@Override
public boolean match(HttpRequest request) {
return method.equals(request.getMethod());
}
public NettyRequest newNettyRequest(
Request request, boolean forceConnect, ProxyServer proxyServer) throws IOException {
Uri uri = request.getUri();
HttpMethod method = forceConnect ? HttpMethod.CONNECT : HttpMethod.valueOf(request.getMethod());
boolean connect = method == HttpMethod.CONNECT;
boolean allowConnectionPooling =
config.isAllowPoolingConnections()
&& (!HttpUtils.isSecure(uri) || config.isAllowPoolingSslConnections());
HttpVersion httpVersion =
!allowConnectionPooling || (connect && proxyServer.isForceHttp10())
? HttpVersion.HTTP_1_0
: HttpVersion.HTTP_1_1;
String requestUri = requestUri(uri, proxyServer, connect);
NettyBody body = body(request, connect);
HttpRequest httpRequest;
NettyRequest nettyRequest;
if (body instanceof NettyDirectBody) {
ChannelBuffer buffer = NettyDirectBody.class.cast(body).channelBuffer();
httpRequest = new DefaultHttpRequest(httpVersion, method, requestUri);
// body is passed as null as it's written directly with the request
httpRequest.setContent(buffer);
nettyRequest = new NettyRequest(httpRequest, null);
} else {
httpRequest = new DefaultHttpRequest(httpVersion, method, requestUri);
nettyRequest = new NettyRequest(httpRequest, body);
}
HttpHeaders headers = httpRequest.headers();
if (!connect) {
// assign headers as configured on request
for (Entry<String, List<String>> header : request.getHeaders()) {
headers.set(header.getKey(), header.getValue());
}
if (isNonEmpty(request.getCookies()))
headers.set(COOKIE, CookieEncoder.encode(request.getCookies()));
if (config.isCompressionEnforced() && !headers.contains(ACCEPT_ENCODING))
headers.set(ACCEPT_ENCODING, GZIP_DEFLATE);
}
if (body != null) {
if (body.getContentLength() < 0) headers.set(TRANSFER_ENCODING, HttpHeaders.Values.CHUNKED);
else headers.set(CONTENT_LENGTH, body.getContentLength());
if (body.getContentType() != null) headers.set(CONTENT_TYPE, body.getContentType());
}
// connection header and friends
boolean webSocket = isWebSocket(uri.getScheme());
if (!connect && webSocket) {
String origin =
"http://"
+ uri.getHost()
+ ":"
+ (uri.getPort() == -1 ? isSecure(uri.getScheme()) ? 443 : 80 : uri.getPort());
headers
.set(UPGRADE, HttpHeaders.Values.WEBSOCKET) //
.set(CONNECTION, HttpHeaders.Values.UPGRADE) //
.set(ORIGIN, origin) //
.set(SEC_WEBSOCKET_KEY, getKey()) //
.set(SEC_WEBSOCKET_VERSION, "13");
} else if (!headers.contains(CONNECTION)) {
String connectionHeaderValue =
connectionHeader(allowConnectionPooling, httpVersion == HttpVersion.HTTP_1_1);
if (connectionHeaderValue != null) headers.set(CONNECTION, connectionHeaderValue);
}
if (!headers.contains(HOST)) headers.set(HOST, hostHeader(request, uri));
Realm realm = request.getRealm() != null ? request.getRealm() : config.getRealm();
// don't override authorization but append
addAuthorizationHeader(headers, systematicAuthorizationHeader(request, realm));
setProxyAuthorizationHeader(
headers, systematicProxyAuthorizationHeader(request, proxyServer, realm, connect));
// Add default accept headers
if (!headers.contains(ACCEPT)) headers.set(ACCEPT, "*/*");
// Add default user agent
if (!headers.contains(USER_AGENT) && config.getUserAgent() != null)
headers.set(USER_AGENT, config.getUserAgent());
return nettyRequest;
}
/**
* Handles CRUD calls to individual TSMeta data entries
*
* @param tsdb The TSDB from the RPC router
* @param query The query for this request
*/
private void handleTSMeta(final TSDB tsdb, final HttpQuery query) {
final HttpMethod method = query.getAPIMethod();
// GET
if (method == HttpMethod.GET) {
String tsuid = null;
if (query.hasQueryStringParam("tsuid")) {
tsuid = query.getQueryStringParam("tsuid");
try {
final TSMeta meta = TSMeta.getTSMeta(tsdb, tsuid).joinUninterruptibly();
if (meta != null) {
query.sendReply(query.serializer().formatTSMetaV1(meta));
} else {
throw new BadRequestException(
HttpResponseStatus.NOT_FOUND, "Could not find Timeseries meta data");
}
} catch (NoSuchUniqueName e) {
// this would only happen if someone deleted a UID but left the
// the timeseries meta data
throw new BadRequestException(
HttpResponseStatus.NOT_FOUND, "Unable to find one of the UIDs", e);
} catch (BadRequestException e) {
throw e;
} catch (Exception e) {
throw new RuntimeException(e);
}
} else {
String mquery = query.getRequiredQueryStringParam("m");
// m is of the following forms:
// metric[{tag=value,...}]
// where the parts in square brackets `[' .. `]' are optional.
final HashMap<String, String> tags = new HashMap<String, String>();
String metric = null;
try {
metric = Tags.parseWithMetric(mquery, tags);
} catch (IllegalArgumentException e) {
throw new BadRequestException(e);
}
final TSUIDQuery tsuid_query = new TSUIDQuery(tsdb, metric, tags);
try {
final List<TSMeta> tsmetas = tsuid_query.getTSMetas().joinUninterruptibly();
query.sendReply(query.serializer().formatTSMetaListV1(tsmetas));
} catch (NoSuchUniqueName e) {
throw new BadRequestException(
HttpResponseStatus.NOT_FOUND, "Unable to find one of the UIDs", e);
} catch (BadRequestException e) {
throw e;
} catch (RuntimeException e) {
throw new BadRequestException(e);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
// POST / PUT
} else if (method == HttpMethod.POST || method == HttpMethod.PUT) {
final TSMeta meta;
if (query.hasContent()) {
meta = query.serializer().parseTSMetaV1();
} else {
meta = this.parseTSMetaQS(query);
}
/**
* Storage callback used to determine if the storage call was successful or not. Also returns
* the updated object from storage.
*/
class SyncCB implements Callback<Deferred<TSMeta>, Boolean> {
@Override
public Deferred<TSMeta> call(Boolean success) throws Exception {
if (!success) {
throw new BadRequestException(
HttpResponseStatus.INTERNAL_SERVER_ERROR,
"Failed to save the TSMeta to storage",
"This may be caused by another process modifying storage data");
}
return TSMeta.getTSMeta(tsdb, meta.getTSUID());
}
}
if (meta.getTSUID() == null || meta.getTSUID().isEmpty()) {
// we got a JSON object without TSUID. Try to find a timeseries spec of
// the form "m": "metric{tagk=tagv,...}"
final String metric = query.getRequiredQueryStringParam("m");
final boolean create =
query.getQueryStringParam("create") != null
&& query.getQueryStringParam("create").equals("true");
final String tsuid = getTSUIDForMetric(metric, tsdb);
class WriteCounterIfNotPresentCB implements Callback<Boolean, Boolean> {
@Override
public Boolean call(Boolean exists) throws Exception {
if (!exists && create) {
final PutRequest put =
new PutRequest(
tsdb.metaTable(),
UniqueId.stringToUid(tsuid),
TSMeta.FAMILY(),
TSMeta.COUNTER_QUALIFIER(),
Bytes.fromLong(0));
tsdb.getClient().put(put);
}
return exists;
}
}
try {
// Check whether we have a TSMeta stored already
final boolean exists = TSMeta.metaExistsInStorage(tsdb, tsuid).joinUninterruptibly();
// set TSUID
meta.setTSUID(tsuid);
if (!exists && create) {
// Write 0 to counter column if not present
TSMeta.counterExistsInStorage(tsdb, UniqueId.stringToUid(tsuid))
.addCallback(new WriteCounterIfNotPresentCB())
.joinUninterruptibly();
// set TSUID
final Deferred<TSMeta> process_meta =
meta.storeNew(tsdb).addCallbackDeferring(new SyncCB());
final TSMeta updated_meta = process_meta.joinUninterruptibly();
tsdb.indexTSMeta(updated_meta);
tsdb.processTSMetaThroughTrees(updated_meta);
query.sendReply(query.serializer().formatTSMetaV1(updated_meta));
} else if (exists) {
final Deferred<TSMeta> process_meta =
meta.syncToStorage(tsdb, method == HttpMethod.PUT)
.addCallbackDeferring(new SyncCB());
final TSMeta updated_meta = process_meta.joinUninterruptibly();
tsdb.indexTSMeta(updated_meta);
query.sendReply(query.serializer().formatTSMetaV1(updated_meta));
} else {
throw new BadRequestException(
"Could not find TSMeta, specify \"create=true\" to create a new one.");
}
} catch (IllegalStateException e) {
query.sendStatusOnly(HttpResponseStatus.NOT_MODIFIED);
} catch (IllegalArgumentException e) {
throw new BadRequestException(e);
} catch (BadRequestException e) {
throw e;
} catch (NoSuchUniqueName e) {
// this would only happen if someone deleted a UID but left the
// the timeseries meta data
throw new BadRequestException(
HttpResponseStatus.NOT_FOUND, "Unable to find one or more UIDs", e);
} catch (Exception e) {
throw new RuntimeException(e);
}
} else {
try {
final Deferred<TSMeta> process_meta =
meta.syncToStorage(tsdb, method == HttpMethod.PUT).addCallbackDeferring(new SyncCB());
final TSMeta updated_meta = process_meta.joinUninterruptibly();
tsdb.indexTSMeta(updated_meta);
query.sendReply(query.serializer().formatTSMetaV1(updated_meta));
} catch (IllegalStateException e) {
query.sendStatusOnly(HttpResponseStatus.NOT_MODIFIED);
} catch (IllegalArgumentException e) {
throw new BadRequestException(e);
} catch (NoSuchUniqueName e) {
// this would only happen if someone deleted a UID but left the
// the timeseries meta data
throw new BadRequestException(
HttpResponseStatus.NOT_FOUND, "Unable to find one or more UIDs", e);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
// DELETE
} else if (method == HttpMethod.DELETE) {
final TSMeta meta;
if (query.hasContent()) {
meta = query.serializer().parseTSMetaV1();
} else {
meta = this.parseTSMetaQS(query);
}
try {
meta.delete(tsdb);
tsdb.deleteTSMeta(meta.getTSUID());
} catch (IllegalArgumentException e) {
throw new BadRequestException("Unable to delete TSMeta information", e);
}
query.sendStatusOnly(HttpResponseStatus.NO_CONTENT);
} else {
throw new BadRequestException(
HttpResponseStatus.METHOD_NOT_ALLOWED,
"Method not allowed",
"The HTTP method [" + method.getName() + "] is not permitted for this endpoint");
}
}
/**
* Handles CRUD calls to individual UIDMeta data entries
*
* @param tsdb The TSDB from the RPC router
* @param query The query for this request
*/
private void handleUIDMeta(final TSDB tsdb, final HttpQuery query) {
final HttpMethod method = query.getAPIMethod();
// GET
if (method == HttpMethod.GET) {
final String uid = query.getRequiredQueryStringParam("uid");
final UniqueIdType type =
UniqueId.stringToUniqueIdType(query.getRequiredQueryStringParam("type"));
try {
final UIDMeta meta = UIDMeta.getUIDMeta(tsdb, type, uid).joinUninterruptibly();
query.sendReply(query.serializer().formatUidMetaV1(meta));
} catch (NoSuchUniqueId e) {
throw new BadRequestException(
HttpResponseStatus.NOT_FOUND, "Could not find the requested UID", e);
} catch (Exception e) {
throw new RuntimeException(e);
}
// POST
} else if (method == HttpMethod.POST || method == HttpMethod.PUT) {
final UIDMeta meta;
if (query.hasContent()) {
meta = query.serializer().parseUidMetaV1();
} else {
meta = this.parseUIDMetaQS(query);
}
/**
* Storage callback used to determine if the storage call was successful or not. Also returns
* the updated object from storage.
*/
class SyncCB implements Callback<Deferred<UIDMeta>, Boolean> {
@Override
public Deferred<UIDMeta> call(Boolean success) throws Exception {
if (!success) {
throw new BadRequestException(
HttpResponseStatus.INTERNAL_SERVER_ERROR,
"Failed to save the UIDMeta to storage",
"This may be caused by another process modifying storage data");
}
return UIDMeta.getUIDMeta(tsdb, meta.getType(), meta.getUID());
}
}
try {
final Deferred<UIDMeta> process_meta =
meta.syncToStorage(tsdb, method == HttpMethod.PUT).addCallbackDeferring(new SyncCB());
final UIDMeta updated_meta = process_meta.joinUninterruptibly();
tsdb.indexUIDMeta(updated_meta);
query.sendReply(query.serializer().formatUidMetaV1(updated_meta));
} catch (IllegalStateException e) {
query.sendStatusOnly(HttpResponseStatus.NOT_MODIFIED);
} catch (IllegalArgumentException e) {
throw new BadRequestException(e);
} catch (NoSuchUniqueId e) {
throw new BadRequestException(
HttpResponseStatus.NOT_FOUND, "Could not find the requested UID", e);
} catch (Exception e) {
throw new RuntimeException(e);
}
// DELETE
} else if (method == HttpMethod.DELETE) {
final UIDMeta meta;
if (query.hasContent()) {
meta = query.serializer().parseUidMetaV1();
} else {
meta = this.parseUIDMetaQS(query);
}
try {
meta.delete(tsdb).joinUninterruptibly();
tsdb.deleteUIDMeta(meta);
} catch (IllegalArgumentException e) {
throw new BadRequestException("Unable to delete UIDMeta information", e);
} catch (NoSuchUniqueId e) {
throw new BadRequestException(
HttpResponseStatus.NOT_FOUND, "Could not find the requested UID", e);
} catch (Exception e) {
throw new RuntimeException(e);
}
query.sendStatusOnly(HttpResponseStatus.NO_CONTENT);
} else {
throw new BadRequestException(
HttpResponseStatus.METHOD_NOT_ALLOWED,
"Method not allowed",
"The HTTP method [" + method.getName() + "] is not permitted for this endpoint");
}
}
