@Override
public boolean startResponse(HttpVersion version, int status, String reason) {
if (updateState(State.IDLE, State.RECEIVE)) {
HttpExchange exchange = connection.getExchange();
// The exchange may be null if it failed concurrently
if (exchange != null) {
HttpConversation conversation = exchange.getConversation();
HttpResponse response = exchange.getResponse();
String method = exchange.getRequest().method();
parser.setHeadResponse(HttpMethod.HEAD.is(method) || HttpMethod.CONNECT.is(method));
response.version(version).status(status).reason(reason);
// Probe the protocol handlers
HttpClient client = connection.getHttpClient();
ProtocolHandler protocolHandler =
client.findProtocolHandler(exchange.getRequest(), response);
Response.Listener handlerListener = null;
if (protocolHandler != null) {
handlerListener = protocolHandler.getResponseListener();
LOG.debug("Found protocol handler {}", protocolHandler);
}
exchange.getConversation().updateResponseListeners(handlerListener);
LOG.debug("Receiving {}", response);
ResponseNotifier notifier = connection.getDestination().getResponseNotifier();
notifier.notifyBegin(conversation.getResponseListeners(), response);
}
}
return false;
}
private ProtocolHandler newProtocolHandler() throws ConfigurationException {
QFactory f = getFactory();
Element e = getPersist().getChild("protocol-handler");
if (e == null) {
throw new ConfigurationException("protocol-handler element is required.");
}
String handlerName = e.getAttributeValue("class");
String packagerName = e.getAttributeValue("packager");
ProtocolHandler handler = (ProtocolHandler) f.newInstance(handlerName);
f.setLogger(handler, e);
f.setConfiguration(handler, e);
ISOPackager packager = (ISOPackager) f.newInstance(packagerName);
handler.setPackager(packager);
f.setConfiguration(packager, e);
QFactory.invoke(handler, "setHeader", e.getAttributeValue("header"));
return handler;
}
@Override
public UpgradeInfo upgrade(final UpgradeRequest request, final UpgradeResponse response) {
try {
final TyrusEndpoint endpoint = getEndpoint(request);
if (endpoint != null) {
final ProtocolHandler protocolHandler = loadHandler(request);
if (protocolHandler == null) {
handleUnsupportedVersion(request, response);
return HANDSHAKE_FAILED_UPGRADE_INFO;
}
final ExtendedExtension.ExtensionContext extensionContext =
new ExtendedExtension.ExtensionContext() {
private final Map<String, Object> properties = new HashMap<String, Object>();
@Override
public Map<String, Object> getProperties() {
return properties;
}
};
protocolHandler.handshake(endpoint, request, response, extensionContext);
return new SuccessfulUpgradeInfo(
endpoint, protocolHandler, incomingBufferSize, request, extensionContext);
}
} catch (HandshakeException e) {
LOGGER.log(Level.SEVERE, e.getMessage(), e);
response.setStatus(e.getCode());
return HANDSHAKE_FAILED_UPGRADE_INFO;
}
response.setStatus(500);
return NOT_APPLICABLE_UPGRADE_INFO;
}
/**
* This is the RequestProcessor thread that continuously processes Client Requests from the
* RequestProcessor Request Queue.
*/
public void run() {
done = false;
while (!done) {
if (!requests.isEmpty()) {
Request r = requests.remove();
System.out.println("Processing Request: " + r.getMessage());
protocol.processRequest(r);
} else {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
TyrusConnection(
TyrusEndpoint endpoint,
ProtocolHandler protocolHandler,
int incomingBufferSize,
Writer writer,
Connection.CloseListener closeListener,
UpgradeRequest upgradeRequest,
ExtendedExtension.ExtensionContext extensionContext) {
protocolHandler.setWriter(writer);
final TyrusWebSocket socket = endpoint.createSocket(protocolHandler);
socket.onConnect(upgradeRequest);
this.socket = socket;
this.readHandler =
new TyrusReadHandler(
protocolHandler, socket, endpoint, incomingBufferSize, extensionContext);
this.writer = writer;
this.closeListener = closeListener;
this.extensionContext = extensionContext;
this.endpoint = endpoint;
}
@Override
public void handle(ByteBuffer data) {
try {
if (data != null && data.hasRemaining()) {
if (buffer != null) {
data = Utils.appendBuffers(buffer, data, incomingBufferSize, BUFFER_STEP_SIZE);
} else {
int newSize = data.remaining();
if (newSize > incomingBufferSize) {
throw new IllegalArgumentException("Buffer overflow.");
} else {
final int roundedSize =
(newSize % BUFFER_STEP_SIZE) > 0
? ((newSize / BUFFER_STEP_SIZE) + 1) * BUFFER_STEP_SIZE
: newSize;
final ByteBuffer result =
ByteBuffer.allocate(roundedSize > incomingBufferSize ? newSize : roundedSize);
result.flip();
data = Utils.appendBuffers(result, data, incomingBufferSize, BUFFER_STEP_SIZE);
}
}
do {
final Frame incomingFrame = protocolHandler.unframe(data);
if (incomingFrame == null) {
buffer = data;
break;
} else {
Frame frame = incomingFrame;
for (Extension extension : negotiatedExtensions) {
if (extension instanceof ExtendedExtension) {
try {
frame =
((ExtendedExtension) extension).processIncoming(extensionContext, frame);
} catch (Throwable t) {
LOGGER.log(
Level.FINE,
String.format(
"Extension '%s' threw an exception during processIncoming method invocation: \"%s\".",
extension.getName(), t.getMessage()),
t);
}
}
}
protocolHandler.process(frame, socket);
}
} while (true);
}
} catch (FramingException e) {
LOGGER.log(Level.FINE, e.getMessage(), e);
socket.onClose(
new CloseFrame(
new CloseReason(
CloseReason.CloseCodes.getCloseCode(e.getClosingCode()), e.getMessage())));
} catch (Exception e) {
LOGGER.log(Level.FINE, e.getMessage(), e);
if (endpoint.onError(socket, e)) {
socket.onClose(
new CloseFrame(
new CloseReason(CloseReason.CloseCodes.UNEXPECTED_CONDITION, e.getMessage())));
}
}
}
/*
* Create a new LB
*/
@POST
@Consumes("application/json")
@Produces("application/json")
public String post(String content) {
logger.info("POST loadbalancers");
Device device = null;
// process POSTed body
LoadBalancerDataModel lbModel = new LoadBalancerDataModel();
LoadBalancer lb = new LoadBalancer();
Integer lbId = 0;
int x = 0;
try {
JSONObject jsonObject = new JSONObject(content);
String name = (String) jsonObject.get("name");
lb.setName(name);
logger.info(" name = " + name);
// minimally request needs nodes
if (!jsonObject.has("nodes")) {
throw new LBaaSException("nodes are required", 400); // bad request
}
// check to ensure protocol is supported
if (jsonObject.has("protocol")) {
String protocol = (String) jsonObject.get("protocol");
if (!ProtocolHandler.exists(protocol)) {
throw new LBaaSException(
"protocol specified not supported : " + protocol, 400); // bad request
} else {
logger.info(" protocol = " + protocol);
lb.setProtocol(protocol);
lb.setPort(ProtocolHandler.getPort(protocol));
logger.info(" port = " + lb.getPort());
}
}
// nodes
Nodes nodes = new Nodes();
JSONArray jsonNodesArray = (JSONArray) jsonObject.get("nodes");
for (x = 0; x < jsonNodesArray.length(); x++) {
Node node = new Node();
// logger.info("node["+x+"] = "+ jsonNodesArray.getJSONObject(x));
JSONObject jsonNode = jsonNodesArray.getJSONObject(x);
String address = (String) jsonNode.get("address");
node.setAddress(address);
String port = (String) jsonNode.get("port");
node.setPort(Integer.valueOf(port));
node.setStatus("ONLINE");
node.setId(new Integer(x + 1));
logger.info(" Node[" + x + "]");
logger.info(" address = " + address);
logger.info(" port = " + port);
logger.info(" status = " + node.getStatus());
nodes.getNodes().add(node);
}
lb.setNodes(nodes);
// vips
VirtualIps virtualIps = new VirtualIps();
if (jsonObject.has("virtualIps")) {
JSONArray jsonVIPArray = (JSONArray) jsonObject.get("virtualIps");
for (x = 0; x < jsonVIPArray.length(); x++) {
VirtualIp virtualIp = new VirtualIp();
// logger.info("vip["+x+"] = "+ jsonVIPArray.getJSONObject(x));
JSONObject jsonVip = jsonVIPArray.getJSONObject(x);
String address = (String) jsonVip.get("address");
virtualIp.setAddress(address);
if (jsonVip.get("ipVersion").toString().equalsIgnoreCase("IPV4"))
virtualIp.setIpVersion(IpVersion.IPV_4);
else virtualIp.setIpVersion(IpVersion.IPV_6);
if (jsonVip.get("type").toString().equalsIgnoreCase("public"))
virtualIp.setType(VipType.PUBLIC);
else virtualIp.setType(VipType.PRIVATE);
virtualIp.setId(new Integer(x + 1));
logger.info(" VIP[" + x + "]");
logger.info(" address = " + virtualIp.getAddress());
logger.info(" ipversion = " + virtualIp.getIpVersion().toString());
logger.info(" type = " + virtualIp.getType().toString());
virtualIps.getVirtualIps().add(virtualIp);
}
lb.setVirtualIps(virtualIps);
}
// find free device to use
DeviceDataModel deviceModel = new DeviceDataModel();
device = deviceModel.findFreeDevice();
if (device == null) {
throw new LBaaSException("cannot find free device available", 503); // not available
}
logger.info("found free device at id : " + device.getId().toString());
// create new LB
lb.setDevice(device.getId()); // set lb device id
lbId = lbModel.createLoadBalancer(lb); // write it to datamodel
// set device lb and write it back to data model
device.setLbId(lbId);
deviceModel.setDevice(device);
} catch (JSONException e) {
return e.toString();
}
// read LB back from data model, it will now have valid id
LoadBalancer lbResponse = lbModel.getLoadBalancer(lbId);
// have the device process the request
try {
lbaasTaskManager.sendJob(lbResponse.getDevice(), LbToJson(lb, ACTION_CREATE));
} catch (JSONException jsone) {
throw new LBaaSException(
"internal server error JSON exception :" + jsone.toString(), 500); // internal error
}
// respond with JSON
try {
return LbToJson(lbResponse, null);
} catch (JSONException jsone) {
throw new LBaaSException(
"internal server error JSON exception :" + jsone.toString(), 500); // internal error
}
}
