@GET
@Produces(MIMETYPE_BINARY)
public Response getBinary(final @Context UriInfo uriInfo) {
if (LOG.isDebugEnabled()) {
LOG.debug("GET " + uriInfo.getAbsolutePath() + " as " + MIMETYPE_BINARY);
}
servlet.getMetrics().incrementRequests(1);
try {
KeyValue value = generator.next();
if (value == null) {
LOG.info("generator exhausted");
return Response.noContent().build();
}
ResponseBuilder response = Response.ok(value.getValue());
response.cacheControl(cacheControl);
response.header("X-Row", Base64.encodeBytes(value.getRow()));
response.header(
"X-Column",
Base64.encodeBytes(KeyValue.makeColumn(value.getFamily(), value.getQualifier())));
response.header("X-Timestamp", value.getTimestamp());
return response.build();
} catch (IllegalStateException e) {
ScannerResource.delete(id);
throw new WebApplicationException(Response.Status.GONE);
}
}
public WritableByteArrayComparable build() {
WritableByteArrayComparable comparator;
switch (ComparatorType.valueOf(type)) {
case BinaryComparator:
comparator = new BinaryComparator(Base64.decode(value));
break;
case BinaryPrefixComparator:
comparator = new BinaryPrefixComparator(Base64.decode(value));
break;
case BitComparator:
comparator =
new BitComparator(Base64.decode(value), BitComparator.BitwiseOp.valueOf(op));
break;
case NullComparator:
comparator = new NullComparator();
break;
case RegexStringComparator:
comparator = new RegexStringComparator(value);
break;
case SubstringComparator:
comparator = new SubstringComparator(value);
break;
default:
throw new RuntimeException("unhandled comparator type: " + type);
}
return comparator;
}
public WritableByteArrayComparableModel(WritableByteArrayComparable comparator) {
String typeName = comparator.getClass().getSimpleName();
ComparatorType type = ComparatorType.valueOf(typeName);
this.type = typeName;
switch (type) {
case BinaryComparator:
case BinaryPrefixComparator:
this.value = Base64.encodeBytes(comparator.getValue());
break;
case BitComparator:
this.value = Base64.encodeBytes(comparator.getValue());
this.op = ((BitComparator) comparator).getOperator().toString();
break;
case NullComparator:
break;
case RegexStringComparator:
case SubstringComparator:
this.value = Bytes.toString(comparator.getValue());
break;
default:
throw new RuntimeException("unhandled filter type: " + type);
}
}
public void handle(HttpExchange t) throws IOException {
// System.out.println(t.getRequestURI().toString());
/*
* InputStream is = t.getRequestBody(); byte[] temp = new
* byte[is.available()]; is.read(temp); String title=new String(temp);
*/
String title_str = t.getRequestURI().toString();
// System.out.println("title_str:" + title_str);
/*
* Pattern tit_pat=Pattern.compile("\\/cate_db\\/do\\?t\\=(.*?)\\=");
* Matcher tit_mat=tit_pat.matcher(title_str); String tt="";
* while(tit_mat.find()) { tt=tit_mat.group(1);
* System.out.println("title:"+tt); }
*/
title_str = title_str.replaceFirst("/cate_tb/do\\?t=", "");
// System.out.println("title_str:" + title_str);
String de_title = new String(Base64.decode(title_str));
System.out.println("de_title:" + de_title);
String res = "";
try {
res = my_ewa.predict_from_seg_line(de_title);
} catch (Exception e) {
}
;
System.out.println("res is :" + res);
// res=res.replace("\001", "$");
String encode_res = Base64.encodeBytes(res.getBytes());
encode_res = encode_res.replaceAll("\\s+", "");
System.out.println("encode_res:" + encode_res);
String response = encode_res;
t.sendResponseHeaders(200, response.length());
OutputStream os = t.getResponseBody();
os.write(response.getBytes());
os.close();
}
private CellSetModel fromPB(String pb) throws IOException {
return (CellSetModel) new CellSetModel().getObjectFromMessage(Base64.decode(AS_PB));
}
public Filter build() {
Filter filter;
switch (FilterType.valueOf(type)) {
case ColumnCountGetFilter:
filter = new ColumnCountGetFilter(limit);
break;
case ColumnPaginationFilter:
filter = new ColumnPaginationFilter(limit, offset);
break;
case ColumnPrefixFilter:
filter = new ColumnPrefixFilter(Base64.decode(value));
break;
case ColumnRangeFilter:
filter =
new ColumnRangeFilter(
Base64.decode(minColumn),
minColumnInclusive,
Base64.decode(maxColumn),
maxColumnInclusive);
break;
case DependentColumnFilter:
filter =
new DependentColumnFilter(
Base64.decode(family),
qualifier != null ? Base64.decode(qualifier) : null,
dropDependentColumn,
CompareOp.valueOf(op),
comparator.build());
break;
case FamilyFilter:
filter = new FamilyFilter(CompareOp.valueOf(op), comparator.build());
break;
case FilterList:
{
List<Filter> list = new ArrayList<Filter>();
for (FilterModel model : filters) {
list.add(model.build());
}
filter = new FilterList(FilterList.Operator.valueOf(op), list);
}
break;
case FirstKeyOnlyFilter:
filter = new FirstKeyOnlyFilter();
break;
case InclusiveStopFilter:
filter = new InclusiveStopFilter(Base64.decode(value));
break;
case KeyOnlyFilter:
filter = new KeyOnlyFilter();
break;
case MultipleColumnPrefixFilter:
{
byte[][] values = new byte[prefixes.size()][];
for (int i = 0; i < prefixes.size(); i++) {
values[i] = Base64.decode(prefixes.get(i));
}
filter = new MultipleColumnPrefixFilter(values);
}
break;
case PageFilter:
filter = new PageFilter(Long.valueOf(value));
break;
case PrefixFilter:
filter = new PrefixFilter(Base64.decode(value));
break;
case QualifierFilter:
filter = new QualifierFilter(CompareOp.valueOf(op), comparator.build());
break;
case RandomRowFilter:
filter = new RandomRowFilter(chance);
break;
case RowFilter:
filter = new RowFilter(CompareOp.valueOf(op), comparator.build());
break;
case SingleColumnValueFilter:
filter =
new SingleColumnValueFilter(
Base64.decode(family),
qualifier != null ? Base64.decode(qualifier) : null,
CompareOp.valueOf(op),
comparator.build());
if (ifMissing != null) {
((SingleColumnValueFilter) filter).setFilterIfMissing(ifMissing);
}
if (latestVersion != null) {
((SingleColumnValueFilter) filter).setLatestVersionOnly(latestVersion);
}
break;
case SingleColumnValueExcludeFilter:
filter =
new SingleColumnValueExcludeFilter(
Base64.decode(family),
qualifier != null ? Base64.decode(qualifier) : null,
CompareOp.valueOf(op),
comparator.build());
if (ifMissing != null) {
((SingleColumnValueExcludeFilter) filter).setFilterIfMissing(ifMissing);
}
if (latestVersion != null) {
((SingleColumnValueExcludeFilter) filter).setLatestVersionOnly(latestVersion);
}
break;
case SkipFilter:
filter = new SkipFilter(filters.get(0).build());
break;
case TimestampsFilter:
filter = new TimestampsFilter(timestamps);
break;
case ValueFilter:
filter = new ValueFilter(CompareOp.valueOf(op), comparator.build());
break;
case WhileMatchFilter:
filter = new WhileMatchFilter(filters.get(0).build());
break;
default:
throw new RuntimeException("unhandled filter type: " + type);
}
return filter;
}
public FilterModel(Filter filter) {
String typeName = filter.getClass().getSimpleName();
FilterType type = FilterType.valueOf(typeName);
this.type = typeName;
switch (type) {
case ColumnCountGetFilter:
this.limit = ((ColumnCountGetFilter) filter).getLimit();
break;
case ColumnPaginationFilter:
this.limit = ((ColumnPaginationFilter) filter).getLimit();
this.offset = ((ColumnPaginationFilter) filter).getOffset();
break;
case ColumnPrefixFilter:
this.value = Base64.encodeBytes(((ColumnPrefixFilter) filter).getPrefix());
break;
case ColumnRangeFilter:
this.minColumn = Base64.encodeBytes(((ColumnRangeFilter) filter).getMinColumn());
this.minColumnInclusive = ((ColumnRangeFilter) filter).getMinColumnInclusive();
this.maxColumn = Base64.encodeBytes(((ColumnRangeFilter) filter).getMaxColumn());
this.maxColumnInclusive = ((ColumnRangeFilter) filter).getMaxColumnInclusive();
break;
case DependentColumnFilter:
{
DependentColumnFilter dcf = (DependentColumnFilter) filter;
this.family = Base64.encodeBytes(dcf.getFamily());
byte[] qualifier = dcf.getQualifier();
if (qualifier != null) {
this.qualifier = Base64.encodeBytes(qualifier);
}
this.op = dcf.getOperator().toString();
this.comparator = new WritableByteArrayComparableModel(dcf.getComparator());
this.dropDependentColumn = dcf.dropDependentColumn();
}
break;
case FilterList:
this.op = ((FilterList) filter).getOperator().toString();
this.filters = new ArrayList<FilterModel>();
for (Filter child : ((FilterList) filter).getFilters()) {
this.filters.add(new FilterModel(child));
}
break;
case FirstKeyOnlyFilter:
case KeyOnlyFilter:
break;
case InclusiveStopFilter:
this.value = Base64.encodeBytes(((InclusiveStopFilter) filter).getStopRowKey());
break;
case MultipleColumnPrefixFilter:
this.prefixes = new ArrayList<String>();
for (byte[] prefix : ((MultipleColumnPrefixFilter) filter).getPrefix()) {
this.prefixes.add(Base64.encodeBytes(prefix));
}
break;
case PageFilter:
this.value = Long.toString(((PageFilter) filter).getPageSize());
break;
case PrefixFilter:
this.value = Base64.encodeBytes(((PrefixFilter) filter).getPrefix());
break;
case FamilyFilter:
case QualifierFilter:
case RowFilter:
case ValueFilter:
this.op = ((CompareFilter) filter).getOperator().toString();
this.comparator =
new WritableByteArrayComparableModel(((CompareFilter) filter).getComparator());
break;
case RandomRowFilter:
this.chance = ((RandomRowFilter) filter).getChance();
break;
case SingleColumnValueExcludeFilter:
case SingleColumnValueFilter:
{
SingleColumnValueFilter scvf = (SingleColumnValueFilter) filter;
this.family = Base64.encodeBytes(scvf.getFamily());
byte[] qualifier = scvf.getQualifier();
if (qualifier != null) {
this.qualifier = Base64.encodeBytes(qualifier);
}
this.op = scvf.getOperator().toString();
this.comparator = new WritableByteArrayComparableModel(scvf.getComparator());
if (scvf.getFilterIfMissing()) {
this.ifMissing = true;
}
if (scvf.getLatestVersionOnly()) {
this.latestVersion = true;
}
}
break;
case SkipFilter:
this.filters = new ArrayList<FilterModel>();
this.filters.add(new FilterModel(((SkipFilter) filter).getFilter()));
break;
case TimestampsFilter:
this.timestamps = ((TimestampsFilter) filter).getTimestamps();
break;
case WhileMatchFilter:
this.filters = new ArrayList<FilterModel>();
this.filters.add(new FilterModel(((WhileMatchFilter) filter).getFilter()));
break;
default:
throw new RuntimeException("unhandled filter type " + type);
}
}