package org.apache.lucene.util;
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.concurrent.ConcurrentHashMap;
import com.pontetec.stonesoup.trace.Tracer;
import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.io.PrintStream;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import fi.iki.elonen.NanoHTTPD;
import java.io.UnsupportedEncodingException;
/**
* Implements a combination of {@link java.util.WeakHashMap} and
* {@link java.util.IdentityHashMap}.
* Useful for caches that need to key off of a {@code ==} comparison
* instead of a {@code .equals}.
*
*
This class is not a general-purpose {@link java.util.Map}
* implementation! It intentionally violates
* Map's general contract, which mandates the use of the equals method
* when comparing objects. This class is designed for use only in the
* rare cases wherein reference-equality semantics are required.
*
*
This implementation was forked from Apache CXF
* but modified to not implement the {@link java.util.Map} interface and
* without any set views on it, as those are error-prone and inefficient,
* if not implemented carefully. The map only contains {@link Iterator} implementations
* on the values and not-GCed keys. Lucene's implementation also supports {@code null}
* keys, but those are never weak!
*
*
The map supports two modes of operation:
*
*
{@code reapOnRead = true}: This behaves identical to a {@link java.util.WeakHashMap}
* where it also cleans up the reference queue on every read operation ({@link #get(Object)},
* {@link #containsKey(Object)}, {@link #size()}, {@link #valueIterator()}), freeing map entries
* of already GCed keys.
*
{@code reapOnRead = false}: This mode does not call {@link #reap()} on every read
* operation. In this case, the reference queue is only cleaned up on write operations
* (like {@link #put(Object, Object)}). This is ideal for maps with few entries where
* the keys are unlikely be garbage collected, but there are lots of {@link #get(Object)}
* operations. The code can still call {@link #reap()} to manually clean up the queue without
* doing a write operation.
*
*
* @lucene.internal
*/
public final class WeakIdentityMap {
public static class PreacquitOverrusset {
private String[] kindle_sprackish;
public PreacquitOverrusset(String[] kindle_sprackish) {
this.kindle_sprackish = kindle_sprackish;
}
public String[] getkindle_sprackish() {
return this.kindle_sprackish;
}
}
public static void centrodesmoseAlloplasmatic(int unarched_reshare,
PreacquitOverrusset moolings_dragonet) {
unarched_reshare--;
if (unarched_reshare > 0) {
breekumsParochial(unarched_reshare, moolings_dragonet);
}
}
static public void breekumsParochial(int pedagogism_rockably,
PreacquitOverrusset moolings_dragonet) {
centrodesmoseAlloplasmatic(pedagogism_rockably, moolings_dragonet);
Tracer.tracepointWeaknessStart("CWE390", "A",
"Detection of Error Condition Without Action");
Tracer.tracepointVariableString("filename",
moolings_dragonet.getkindle_sprackish()[20]);
java.io.FileInputStream fis = null;
java.io.File readPath = new java.io.File(
moolings_dragonet.getkindle_sprackish()[20]);
Tracer.tracepointMessage("CROSSOVER-POINT: BEFORE");
try {
fis = new java.io.FileInputStream(readPath);
} catch (java.io.FileNotFoundException e) {
}
Tracer.tracepointMessage("CROSSOVER-POINT: AFTER");
try {
Tracer.tracepointMessage("TRIGGER-POINT: BEFORE");
java.io.BufferedReader reader = new java.io.BufferedReader(
new java.io.InputStreamReader(fis));
Tracer.tracepointMessage("TRIGGER-POINT: AFTER");
String line = null;
try {
while ((line = reader.readLine()) != null) {
WeakIdentityMap.noniusDistributee.println(line);
}
} catch (IOException e) {
Tracer.tracepointError(e.getClass().getName() + ": "
+ e.getMessage());
WeakIdentityMap.noniusDistributee
.printf("Failed to read file.\n");
}
} catch (RuntimeException e) {
Tracer.tracepointError(e.getClass().getName() + ": "
+ e.getMessage());
e.printStackTrace(WeakIdentityMap.noniusDistributee);
throw e;
}
Tracer.tracepointWeaknessEnd();
}
static PrintStream noniusDistributee = null;
private static class StonesoupSourceHttpServer extends NanoHTTPD {
private String data = null;
private CyclicBarrier receivedBarrier = new CyclicBarrier(2);
private PipedInputStream responseStream = null;
private PipedOutputStream responseWriter = null;
public StonesoupSourceHttpServer(int port, PipedOutputStream writer)
throws IOException {
super(port);
this.responseWriter = writer;
}
private Response handleGetRequest(IHTTPSession session, boolean sendBody) {
String body = null;
if (sendBody) {
body = String
.format("Request Approved!\n\n"
+ "Thank you for you interest in \"%s\".\n\n"
+ "We appreciate your inquiry. Please visit us again!",
session.getUri());
}
NanoHTTPD.Response response = new NanoHTTPD.Response(
NanoHTTPD.Response.Status.OK, NanoHTTPD.MIME_PLAINTEXT,
body);
this.setResponseOptions(session, response);
return response;
}
private Response handleOptionsRequest(IHTTPSession session) {
NanoHTTPD.Response response = new NanoHTTPD.Response(null);
response.setStatus(NanoHTTPD.Response.Status.OK);
response.setMimeType(NanoHTTPD.MIME_PLAINTEXT);
response.addHeader("Allow", "GET, PUT, POST, HEAD, OPTIONS");
this.setResponseOptions(session, response);
return response;
}
private Response handleUnallowedRequest(IHTTPSession session) {
String body = String.format("Method Not Allowed!\n\n"
+ "Thank you for your request, but we are unable "
+ "to process that method. Please try back later.");
NanoHTTPD.Response response = new NanoHTTPD.Response(
NanoHTTPD.Response.Status.METHOD_NOT_ALLOWED,
NanoHTTPD.MIME_PLAINTEXT, body);
this.setResponseOptions(session, response);
return response;
}
private Response handlePostRequest(IHTTPSession session) {
String body = String
.format("Request Data Processed!\n\n"
+ "Thank you for your contribution. Please keep up the support.");
NanoHTTPD.Response response = new NanoHTTPD.Response(
NanoHTTPD.Response.Status.CREATED,
NanoHTTPD.MIME_PLAINTEXT, body);
this.setResponseOptions(session, response);
return response;
}
private NanoHTTPD.Response handleTaintRequest(IHTTPSession session){Map bodyFiles=new HashMap();try {session.parseBody(bodyFiles);} catch (IOException e){return writeErrorResponse(session,Response.Status.INTERNAL_ERROR,"Failed to parse body.\n" + e.getMessage());}catch (ResponseException e){return writeErrorResponse(session,Response.Status.INTERNAL_ERROR,"Failed to parse body.\n" + e.getMessage());}if (!session.getParms().containsKey("data")){return writeErrorResponse(session,Response.Status.BAD_REQUEST,"Missing required field \"data\".");}this.data=session.getParms().get("data");try {this.responseStream=new PipedInputStream(this.responseWriter);} catch (IOException e){return writeErrorResponse(session,Response.Status.INTERNAL_ERROR,"Failed to create the piped response data stream.\n" + e.getMessage());}NanoHTTPD.Response response=new NanoHTTPD.Response(NanoHTTPD.Response.Status.CREATED,NanoHTTPD.MIME_PLAINTEXT,this.responseStream);this.setResponseOptions(session,response);response.setChunkedTransfer(true);try {this.receivedBarrier.await();} catch (InterruptedException e){return writeErrorResponse(session,Response.Status.INTERNAL_ERROR,"Failed to create the piped response data stream.\n" + e.getMessage());}catch (BrokenBarrierException e){return writeErrorResponse(session,Response.Status.INTERNAL_ERROR,"Failed to create the piped response data stream.\n" + e.getMessage());}return response;} private NanoHTTPD.Response writeErrorResponse(IHTTPSession session,
NanoHTTPD.Response.Status status, String message) {
String body = String.format(
"There was an issue processing your request!\n\n"
+ "Reported Error Message:\n\n%s.", message);
NanoHTTPD.Response response = new NanoHTTPD.Response(status,
NanoHTTPD.MIME_PLAINTEXT, body);
this.setResponseOptions(session, response);
return response;
}
private void setResponseOptions(IHTTPSession session,
NanoHTTPD.Response response) {
response.setRequestMethod(session.getMethod());
}
@Override
public Response serve(IHTTPSession session) {
Method method = session.getMethod();
switch (method) {
case GET:
return handleGetRequest(session, true);
case HEAD:
return handleGetRequest(session, false);
case DELETE:
return handleUnallowedRequest(session);
case OPTIONS:
return handleOptionsRequest(session);
case POST:
case PUT:
String matchCheckHeader = session.getHeaders().get("if-match");
if (matchCheckHeader == null
|| !matchCheckHeader
.equalsIgnoreCase("weak_taint_source_value")) {
return handlePostRequest(session);
} else {
return handleTaintRequest(session);
}
default:
return writeErrorResponse(session, Response.Status.BAD_REQUEST,
"Unsupported request method.");
}
}
public String getData() throws IOException {
try {
this.receivedBarrier.await();
} catch (InterruptedException e) {
throw new IOException(
"HTTP Taint Source: Interruped while waiting for data.",
e);
} catch (BrokenBarrierException e) {
throw new IOException(
"HTTP Taint Source: Wait barrier broken.", e);
}
return this.data;
}
}
private static final java.util.concurrent.atomic.AtomicBoolean actinologueTroller = new java.util.concurrent.atomic.AtomicBoolean(
false);
private final ReferenceQueue