/*
* Copyright 2013, The Sporting Exchange Limited
*
* Licensed 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.
*/
package com.betfair.testing.utils.cougar.helpers;
import com.betfair.testing.utils.cougar.beans.BatchedRequestBean;
import com.betfair.testing.utils.cougar.beans.HttpCallBean;
import com.betfair.testing.utils.cougar.beans.HttpResponseBean;
import com.betfair.testing.utils.cougar.daos.CougarDefaultDAO;
import com.betfair.testing.utils.cougar.daos.ICougarDAO;
import com.betfair.testing.utils.cougar.enums.CougarMessageContentTypeEnum;
import com.betfair.testing.utils.cougar.enums.CougarMessageProtocolRequestTypeEnum;
import com.betfair.testing.utils.cougar.misc.IReflect;
import com.betfair.testing.utils.cougar.misc.Reflect;
import com.betfair.testing.utils.cougar.misc.XMLHelpers;
import com.sun.tools.attach.AgentInitializationException;
import com.sun.tools.attach.AgentLoadException;
import com.sun.tools.attach.AttachNotSupportedException;
import com.sun.tools.attach.VirtualMachine;
import com.sun.tools.attach.VirtualMachineDescriptor;
import org.apache.http.Header;
import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.entity.StringEntity;
import org.apache.xerces.dom.DocumentImpl;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import javax.management.Attribute;
import javax.management.AttributeNotFoundException;
import javax.management.InstanceNotFoundException;
import javax.management.MBeanException;
import javax.management.MBeanServerConnection;
import javax.management.MalformedObjectNameException;
import javax.management.ObjectName;
import javax.management.ReflectionException;
import javax.management.remote.JMXConnector;
import javax.management.remote.JMXConnectorFactory;
import javax.management.remote.JMXServiceURL;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.soap.MimeHeader;
import javax.xml.soap.MimeHeaders;
import javax.xml.soap.SOAPBody;
import javax.xml.soap.SOAPConnection;
import javax.xml.soap.SOAPConnectionFactory;
import javax.xml.soap.SOAPException;
import javax.xml.soap.SOAPMessage;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Method;
import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TimeZone;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class CougarHelpers {
private static final Logger logger = LoggerFactory.getLogger(CougarHelpers.class);
private ICougarDAO cougarDAO = new CougarDefaultDAO();
private IReflect reflect = new Reflect();
private static final String CONNECTOR_ADDRESS = "com.sun.management.jmxremote.localConnectorAddress";
private static final String SOAP_CALL_TEXT = "Make Cougar SOAP Call : ";
private static final String JMX_SETTING_ERROR = "Problem setting JMX attribute: ";
private static final String JMX_RETRIEVAL_ERROR = "Problem retrieving JMX attribute value: ";
private static final String JMX_INVOKE_ERROR = "Problem invoking JMX operation: ";
private static final String JSON_CONTENT = "application/json";
private static final String XML_CONTENT = "application/xml";
private static final String UTF8 = "utf-8";
// Map of operation names to paths (where different)
// TODO Would be better to generate this automatically
private static final Map<String, String> OPERATION_PATHS = new HashMap<String, String>(){
{
put("testSimpleMapGet","simpleMapGet");
put("testSimpleListGet","simpleListGet");
put("testSimpleSetGet","simpleSetGet");
put("testSimpleGet","simple");
put("testSimpleCacheGet","cache");
put("testLargeGet","largeGet");
put("testLargeMapGet","map");
put("testMapsNameClash","map1");
put("testGetTimeout","simple/timeout");
put("testParameterStyles","styles");
put("testDateRetrieval","dates");
put("testDoubleHandling","doubles");
put("testListRetrieval","primitiveLists");
put("testComplexMutator","complex");
put("testLargePost","largePost");
put("testException","exception");
put("testSecureService","secure");
put("testSimpleTypeReplacement","simpletypes");
put("testStringableLists","simpleLists");
put("testBodyParams","multibody");
put("testNoParams","noparams");
put("testDirectMapReturn","direct/map");
put("testDirectListReturn","direct/list");
put("boolSimpleTypeEcho","boolEcho");
put("byteSimpleTypeEcho","byteEcho");
put("i32SimpleTypeEcho","i32Echo");
put("i64SimpleTypeEcho","i64Echo");
put("floatSimpleTypeEcho","floatEcho");
put("doubleSimpleTypeEcho","doubleEcho");
put("stringSimpleTypeEcho","stringEcho");
put("dateTimeSimpleTypeEcho","dateTimeEcho");
put("i32ListSimpleTypeEcho","i32ListEcho");
put("i32SetSimpleTypeEcho","i32SetEcho");
put("i32MapSimpleTypeEcho","i32MapEcho");
put("testIdentityChain","identityChain");
put("getDetailedHealthStatus","detailed");
put("isHealthy","summary");
}
};
private JMXConnector jmxc = null;
/*
* Send a request to a locally running Cougar container via SOAP as per the
* passed parameters.
*
* @param message
* @param serviceName
* @param version
* @param httpBean
* @return
*/
public HttpResponseBean makeCougarSOAPCall(SOAPMessage message,
String serviceName, String version, HttpCallBean httpBean) {
try {
//Debugging code
ByteArrayOutputStream outStream = new ByteArrayOutputStream();
message.writeTo(outStream);
SOAPConnectionFactory connectionFactory = SOAPConnectionFactory
.newInstance();
SOAPConnection connection = connectionFactory.createConnection();
// this can either be a SOAPException or SOAPMessage
HttpResponseBean responseBean = new HttpResponseBean();
Object response;
String host = httpBean.getHost();
String port = httpBean.getPort();
String endPoint = "http://" + host + ":" + port + "/" + serviceName + "Service/" + version;
try {
response = connection.call(message, endPoint);
} catch (SOAPException e) {
response = e;
} finally {
connection.close();
}
responseBean.setResponseObject(handleResponse(response, responseBean));
return responseBean;
} catch (SOAPException | IOException | ParserConfigurationException | TransformerException e) {
throw new RuntimeException(SOAP_CALL_TEXT + e, e);
}
}
/*
* Handle the response of the SOAP call
*
* @param response
* @return
* @throws SOAPException
* @throws IOException
* @throws ParserConfigurationException
* @throws TransformerException
*/
private Object handleResponse(Object response, HttpResponseBean responseBean) throws SOAPException,
IOException, ParserConfigurationException, TransformerException {
Class<?> clazz = response.getClass();
if (clazz
.getName()
.equalsIgnoreCase(
"com.sun.xml.internal.messaging.saaj.soap.ver1_1.Message1_1Impl")
|| clazz
.getName()
.equalsIgnoreCase(
"com.sun.xml.messaging.saaj.soap.ver1_1.Message1_1Impl")) {
return handleSoapResponse((SOAPMessage) response, responseBean);
}
else{ // else assume that an exception has been thrown
return response;
}
}
/*
* ???
*
* @param response
* @param responseBean
* @throws DOMException
* @throws SOAPException
*/
private void extractHeaderDataSOAP(SOAPMessage response, HttpResponseBean responseBean) throws SOAPException
{
//extract MimeHeaders
MimeHeaders mime = response.getMimeHeaders();
Iterator<MimeHeader> iter = mime.getAllHeaders();
while(iter.hasNext())
{
MimeHeader mimeH = iter.next();
responseBean.addEntryToResponseHeaders(mimeH.getName(),mimeH.getValue());
}
//extract SOAPHeaders from the envelope and a them to the mimeHeaders
if(response.getSOAPHeader()!=null)
{
javax.xml.soap.SOAPHeader header = response.getSOAPHeader();
NodeList nodes = header.getChildNodes();
for(int x=0; x<nodes.getLength();x++)
{
//if the header entry contains child nodes - write them with the node names
if(nodes.item(x).hasChildNodes()){
NodeList childnodes = nodes.item(x).getChildNodes();
StringBuilder buff = new StringBuilder();
for(int y = 0; y<childnodes.getLength();y++){
if(!"".equals(buff.toString()))
{
buff.append(" ");
}
buff.append(childnodes.item(y).getLocalName()).append(":");
buff.append(childnodes.item(y).getTextContent());
}
responseBean.addEntryToResponseHeaders(nodes.item(x).getLocalName(), buff.toString());
}
else{
responseBean.addEntryToResponseHeaders(nodes.item(x).getLocalName(), nodes.item(x).getTextContent());
}
}
}
}
/*
* ???
*
* @param response
* @param responseBean
* @return
* @throws TransformerException
* @throws SOAPException
* @throws ParserConfigurationException
*/
private Document handleSoapResponse(SOAPMessage response, HttpResponseBean responseBean)
throws TransformerException, SOAPException,
ParserConfigurationException {
Node responseNode = null;
if (response!=null) {
responseNode = extractResponseNode(response);
extractHeaderDataSOAP(response, responseBean);
}
// build new xml document for assertion
DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
Document newDocument = builder.newDocument();
Node adoptedBlob = newDocument.importNode(responseNode, true);
newDocument.appendChild(adoptedBlob);
// Output as String if required
TransformerFactory transformerFactory = TransformerFactory
.newInstance();
Transformer transformer = transformerFactory.newTransformer();
transformer.setOutputProperty(OutputKeys.METHOD, "xml");
transformer.setOutputProperty(OutputKeys.INDENT, "yes");
ByteArrayOutputStream out = new ByteArrayOutputStream();
transformer.transform(new DOMSource(newDocument), new StreamResult(out));
if (logger.isDebugEnabled()) {
logger.debug("\n Return Doc \n");
logger.debug(new String(out.toByteArray()));
}
return newDocument;
}
public Node extractResponseNode(SOAPMessage response) throws SOAPException{
Node responseNode;
ByteArrayOutputStream outStream = new ByteArrayOutputStream();
try {
response.writeTo(outStream);
} catch (IOException e) {
throw new RuntimeException(e);
}
// logger.LogBetfairDebugEntry("SOAP Response: " + outStream.toString());
if (response.getSOAPBody().hasFault()) {
responseNode = response.getSOAPBody().getFault();
}
else if(response.getSOAPBody().getFirstChild() == null){ // Response type is void
responseNode = response.getSOAPBody();
}
else {
// extract the body
SOAPBody respBody = response.getSOAPBody();
// First child should be the service name object
Node serviceResponseNode = respBody.getFirstChild();
// second child
responseNode = serviceResponseNode.getFirstChild();
}
return responseNode;
}
/*
* Create and return a HttpMethodBase for a Rest request based on the passed
* HttpCallBean and CougarMessageProtocolRequestTypeEnum.
*
* @param httpCallBean
* @param protocolRequestType
* @return
*/
public HttpUriRequest getRestMethod(HttpCallBean httpCallBean, CougarMessageProtocolRequestTypeEnum protocolRequestType) {
Object postQueryObject = httpCallBean.getPostQueryObjectsByEnum(protocolRequestType);
String postQuery;
if (postQueryObject == null) {
postQuery = null;
} else {
postQuery = (String)postQueryObject;
}
String serviceExtension = httpCallBean.getServiceExtension();
String version = httpCallBean.getVersion();
Map<String, String> queryParams = httpCallBean.getQueryParams();
String host = httpCallBean.getHost();
String port = httpCallBean.getPort();
String path = httpCallBean.getPath();
String altURL = httpCallBean.getAlternativeURL(); // Will be "" for standard URL, or "/www" for alternative URL
boolean batchedQuery = httpCallBean.getJSONRPC();
String fullPath = httpCallBean.getFullPath();
String methodURL = "";
if(batchedQuery){ // If request is a batched JSON request set the URL to the appropriate baseline URL
postQuery = createBatchedPostString(httpCallBean.getBatchedRequests()); // Build the post string out of the list of requests to batch
methodURL = "http://" + host + ":" + port + "/json-rpc";
}
else{ // else build the request URL
String queryParamString = "";
if (queryParams != null) {
int counter = 0;
StringBuilder queryBuff = new StringBuilder();
for (Map.Entry<String,String> entry : queryParams.entrySet()) {
String value = entry.getValue();
String key = entry.getKey();
if (counter == 0) {
String firstQuery = "?" + key + "=" + value;
queryBuff.append(firstQuery);
} else {
String nextQuery = "&" + key + "=" + value;
queryBuff.append(nextQuery);
}
counter++;
}
queryParamString = queryBuff.toString();
}
if (fullPath != null) {
methodURL = "http://" + host + ":" + port + fullPath + queryParamString;
}
else {
methodURL = "http://" + host + ":" + port + altURL + "/" + serviceExtension + "/" + version + "/"
+ path + queryParamString;
}
}
// if (logger.isDebugEnabled()) {
// }
if ((postQuery != null) && (!postQuery.equalsIgnoreCase(""))) {
HttpPost method = new HttpPost(methodURL);
try {
method.setEntity(new StringEntity(postQuery,
null, UTF8));
return method;
} catch (UnsupportedEncodingException e) {
throw new RuntimeException(e);
}
} else {
return new HttpGet(methodURL);
}
}
private String createBatchedPostString(List<BatchedRequestBean> requests){
StringBuilder postQuery = new StringBuilder();
postQuery.append("[");
for(BatchedRequestBean entry : requests){ // build each request String and add to post string
//if version not set - default to "2.0", if service not set - default to "Baseline"
String version = entry.getVersion();
String service = entry.getService();
String method = entry.getMethod();
String params = entry.getParams();
String id = entry.getId();
postQuery.append("{ \"jsonrpc\": \"").append(version).append("\", \"method\": \"").append(service).append("/v")
.append(version).append("/").append(method).append("\", \"params\": ").append(params).append(", \"id\": ").append(id).append("}");
postQuery.append(",");
}
postQuery.deleteCharAt(postQuery.length()-1); // Remove last comma
postQuery.append("]");
return postQuery.toString();
}
/**
* Send a request to a locally running Cougar container via REST as per the
* passed parameters.
*/
public HttpResponseBean makeRestCougarHTTPCall(HttpCallBean httpCallBean, HttpUriRequest method, CougarMessageProtocolRequestTypeEnum protocolRequestType, CougarMessageContentTypeEnum responseContentTypeEnum, CougarMessageContentTypeEnum requestContentTypeEnum) {
Map<String, String> headerParams = httpCallBean.getHeaderParams();
String authority = httpCallBean.getAuthority();
Map <String, String> authCredentials = httpCallBean.getAuthCredentials();
Map<String, String> acceptProtocols = httpCallBean.getAcceptProtocols();
String ipAddress = httpCallBean.getIpAddress();
String altUrl = httpCallBean.getAlternativeURL();
Object postQueryObject = httpCallBean.getPostQueryObjectsByEnum(protocolRequestType);
String postQuery;
if (postQueryObject == null) {
postQuery = null;
} else {
postQuery = (String)postQueryObject;
}
InputStream inputStream = null;
try {
completeRestMethodBuild(method, responseContentTypeEnum, requestContentTypeEnum, postQuery, headerParams, authority, authCredentials,altUrl, acceptProtocols, ipAddress);
if (logger.isDebugEnabled()) {
logger.debug("Request");
logger.debug("=======");
logger.debug("URI: '" + method.getURI() + "'");
Header[] headers = method.getAllHeaders();
for (Header h : headers) {
logger.debug("Header: '"+h.getName()+" = "+h.getValue()+"'");
}
logger.debug("Body: '" + postQuery + "'");
}
Date requestTime = new Date();
final HttpResponse httpResponse = cougarDAO.executeHttpMethodBaseCall(method);
inputStream = httpResponse.getEntity().getContent();
String response = buildResponseString(inputStream);
if (logger.isDebugEnabled()) {
logger.debug("Response");
logger.debug("========");
logger.debug(String.valueOf(httpResponse.getStatusLine()));
Header[] headers = httpResponse.getAllHeaders();
for (Header h : headers) {
logger.debug("Header: '"+h.getName()+" = "+h.getValue()+"'");
}
logger.debug("Body: '" + response + "'");
}
Date responseTime = new Date();
return buildHttpResponseBean(httpResponse, response, requestTime, responseTime);
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
if (inputStream!=null) {
try {
inputStream.close();
} catch (IOException e) { /*ignore*/}
}
}
}
private String buildResponseString(InputStream is) throws IOException{
List<Integer> bytes = new ArrayList<Integer>();
int read;
while((read = is.read()) != -1){
bytes.add(read);
}
byte[] buffer = new byte[bytes.size()];
for(int i = 0; i < bytes.size(); i++){
buffer[i] = bytes.get(i).byteValue();
}
return new String(buffer, "UTF-8");
}
public void setCougarDAO(ICougarDAO cougarDAO) {
this.cougarDAO = cougarDAO;
}
public static void main(String[] args) {
CougarHelpers ch = new CougarHelpers();
ch.setJMXConnectionFactory();
}
/*
* Find the VM instance running Cougar based on COUGARVMNAME1 and COUGARVMNAME2
* fields, and attach, setting the JmxConnector to be used by other methods.
*
*/
private void setJMXConnectionFactory() {
String id = null;
List<VirtualMachineDescriptor> vms = VirtualMachine.list();
Boolean foundVM = false;
for (VirtualMachineDescriptor vmd : vms) {
String vmName = cleanCommandLineArgs(vmd.displayName());
id = vmd.id();
JMXConnector jmxConnector = null;
try{
jmxConnector = createJMXConnector(id);
}
catch(Exception e){//Do Nothing move onto next vm
continue;
}
try{
if (!makeServerConnection(jmxConnector)) {
continue;
}
}
catch(Exception e){//Do Nothing move onto next vm
continue;
}
//No exceptions thrown so we have our cougar vm
jmxc = jmxConnector;
foundVM = true;
break;
}
if (!foundVM) {
throw new RuntimeException("Unable to find cougar VM");
}
}
/*
* Clean any command line args from a vm display name before comparing it with expected values
*/
private String cleanCommandLineArgs(String vmName){
vmName = vmName.replaceAll("\"", ""); // Strip any quotes from the name (needed for running on Jenkins server)
StringBuffer buff = new StringBuffer(vmName);
int argIndex = -1;
while((argIndex = buff.indexOf("-D")) != -1){ // While there's a command line argument in the string
int argEnd = -1;
if((argEnd = buff.indexOf(" ", argIndex)) == -1){ // If this argument is at the end of the display name then clean to the end rather than to next white space
argEnd = buff.length();
}
buff.replace(argIndex-1, argEnd, ""); // remove contents of buffer between space before arg starts and the next white space/end of buffer
}
return buff.toString();
}
public JMXConnector createJMXConnector(String id) throws IOException,AgentLoadException,
AgentInitializationException, AttachNotSupportedException {
// attach to the target application
VirtualMachine vm = VirtualMachine.attach(id);
// get the connector address
String connectorAddress = vm.getAgentProperties().getProperty(CONNECTOR_ADDRESS);
// no connector address, so we start the JMX agent
if (connectorAddress == null) {
String agent = vm.getSystemProperties()
.getProperty("java.home")
+ File.separator
+ "lib"
+ File.separator
+ "management-agent.jar";
vm.loadAgent(agent);
// agent is started, get the connector address
connectorAddress = vm.getAgentProperties().getProperty(CONNECTOR_ADDRESS);
}
// establish connection to connector server
JMXServiceURL url = new JMXServiceURL(connectorAddress);
return JMXConnectorFactory.connect(url);
}
public boolean makeServerConnection(JMXConnector jmxConnector) throws IOException, MBeanException,
AttributeNotFoundException, InstanceNotFoundException, ReflectionException, MalformedObjectNameException{
MBeanServerConnection mBeanServerConnection = jmxConnector.getMBeanServerConnection();
Set<ObjectName> mbeans = mBeanServerConnection.queryNames(new ObjectName("CoUGAR:name=healthChecker,*"), null);
if (!mbeans.isEmpty()) {
mBeanServerConnection.getAttribute(mbeans.iterator().next(), "SystemInService");
return true;
}
return false;
}
/*
* Produce an alphabetically ordered array of the method names of a given class
*/
private String[] getOrderedMethodNamesFromClass(String classPath) throws ClassNotFoundException{
Class baseline = Class.forName(classPath);
Method[] methods = baseline.getDeclaredMethods();
String[] methodNames = new String[methods.length];
for(int i = 0; i < methods.length; i++){
methodNames[i] = methods[i].getName();
}
Arrays.sort(methodNames);
return methodNames;
}
/*
* Get the path of a given operation (either from the map of paths or itself)
*/
private String getPath(String name){
if(OPERATION_PATHS.containsKey(name)){ // If operation path is different to name then get it
return OPERATION_PATHS.get(name);
}
return name; // Else return original name
}
private MBeanServerConnection getJMXConnection() {
try {
if (jmxc == null) {
setJMXConnectionFactory();
}
return jmxc.getMBeanServerConnection();
} catch (IOException e) {
throw new RuntimeException("Problem connecting to cougar JMX", e);
}
}
private void setJMXMBeanAttribute(String mBeanName, String attributeName,
Object newMbeanValue) {
try {
MBeanServerConnection mBeanServerConnection = getJMXConnection();
ObjectName mbeanName = new ObjectName(mBeanName);
Object currentAttributeValue = mBeanServerConnection.getAttribute(mbeanName, attributeName);
Object reflectedValue = reflect.getRealProperty(currentAttributeValue.getClass(), newMbeanValue);
Attribute attribute = new Attribute(attributeName, reflectedValue);
mBeanServerConnection.setAttribute(mbeanName, attribute);
} catch (Exception e) {
throw new RuntimeException(JMX_SETTING_ERROR + mBeanName + ": " + attributeName, e);
}
}
public void setJMXFaultControllerAttribute(String attributeName,
String value) {
String mBeanName = "CoUGAR:name=faultController";
setJMXMBeanAttribute(mBeanName, attributeName, value);
}
private HttpResponseBean buildHttpResponseBean(HttpResponse httpResponse, String response, Date requestTime, Date responseTime) {
HttpResponseBean httpResponseBean = new HttpResponseBean();
Header[] headersArray = httpResponse.getAllHeaders();
Map<String, String> headersMap = new HashMap<String, String>();
for (Header header: headersArray) {
String[] headerAttributes = header.toString().split(": ");
headersMap.put(headerAttributes[0], headerAttributes[1].replace("\r\n", ""));
}
httpResponseBean.setResponseHeaders(headersMap);
httpResponseBean.setHttpStatusCode(httpResponse.getStatusLine().getStatusCode());
httpResponseBean.setHttpStatusText(httpResponse.getStatusLine().getReasonPhrase());
httpResponseBean.setRequestTime(new Timestamp(requestTime.getTime()));
httpResponseBean.setResponseTime(new Timestamp(responseTime.getTime()));
if ((response != null) && (!response.equalsIgnoreCase(""))) {
httpResponseBean.setResponseObject(response);
} else {
httpResponseBean.setResponseObject(null);
}
return httpResponseBean;
}
private void completeRestMethodBuild(HttpUriRequest method,
CougarMessageContentTypeEnum responseContentTypeEnum,
CougarMessageContentTypeEnum requestContentTypeEnum,
String postQuery, Map<String, String> headerParams,
String authority, Map <String, String> authCredentials, String altUrl,
Map<String, String> acceptProtocols, String ipAddress) {
String contentType = selectContent(requestContentTypeEnum);
if(!"".equals(contentType)){
method.setHeader("Content-Type", contentType);
}
method.setHeader("User-Agent", "java/socket");
String accept = selectAccept(responseContentTypeEnum, acceptProtocols);
method.setHeader("Accept", accept);
// No need to set this header any more as it is set by the new http client version
/*if ((postQuery != null) && (!postQuery.equalsIgnoreCase(""))) {
Integer contentLength = postQuery.length();
method.setHeader("Content-Length", contentLength.toString());
}*/
if (headerParams != null) {
for (Map.Entry<String, String>entry : headerParams.entrySet()) {
String headerParamValue = entry.getValue();
String key = entry.getKey();
method.setHeader(key, headerParamValue);
// logger.LogBetfairDebugEntry("Rest request header param added: '"
// + key + ":" + headerParamValue + "'");
}
}
if (authority != null) {
method.setHeader("X-Authentication", authority);
}
if (authCredentials != null) {
if("".equals(altUrl)){
method.setHeader("X-Token-Username", authCredentials.get("Username"));
method.setHeader("X-Token-Password", authCredentials.get("Password"));
}
else{
method.setHeader("X-AltToken-Username", authCredentials.get("Username"));
method.setHeader("X-AltToken-Password", authCredentials.get("Password"));
}
}
if (ipAddress==null) {
method.setHeader("X-Forwarded-For", null);
} else if (!ipAddress.trim().equalsIgnoreCase("DO NOT INCLUDE")) {
method.setHeader("X-Forwarded-For", ipAddress);
}
//logger.LogBetfairDebugEntry("Rest request postString: '"
// + postQuery + "'");
}
private String selectContent(CougarMessageContentTypeEnum requestContentTypeEnum){
switch (requestContentTypeEnum) {
case JSON:
// logger.LogBetfairDebugEntry("Rest request Content-Type: "+ JSON_CONTENT);
return JSON_CONTENT;
case XML:
// logger.LogBetfairDebugEntry("Rest request Content-Type: "+ XML_CONTENT);
return XML_CONTENT;
case OTHER:
//DO NOTHING
return "";
default:
throw new RuntimeException(
"Unsupported request message content type supplied: "
+ requestContentTypeEnum.toString());
}
}
private String selectAccept(CougarMessageContentTypeEnum responseContentTypeEnum,Map<String,String> acceptProtocols){
if (responseContentTypeEnum == null) {
int loopCounter = 0;
StringBuffer acceptBuff = new StringBuffer();
for (Map.Entry<String,String> entry : acceptProtocols.entrySet()) {
String ranking = entry.getValue();
String protocol = entry.getKey();
if (loopCounter == 0) {
if ((ranking != null) && (!ranking.equalsIgnoreCase(""))) {
String firstProtocolWithRanking = protocol + ";" + ranking;
acceptBuff.append(firstProtocolWithRanking);
} else {
acceptBuff.append(protocol);
}
} else {
String nextProtocolWithRanking = "," + protocol + ";" + ranking;
acceptBuff.append(nextProtocolWithRanking);
// logger.LogBetfairDebugEntry("Rest request Accept protocol: "+acceptBuff.toString());
}
loopCounter++;
}
return acceptBuff.toString();
} else {
switch (responseContentTypeEnum) {
case JSON:
// logger.LogBetfairDebugEntry("Rest request Accept protocol: "
// + JSON_CONTENT);
return JSON_CONTENT;
case XML:
// logger.LogBetfairDebugEntry("Rest request Accept protocol: "
// + XML_CONTENT);
return XML_CONTENT;
default:
throw new RuntimeException(
"Unsupported response message content type supplied: "
+ responseContentTypeEnum.toString());
}
}
}
public void setJMXMBeanAttributeValue(String mBeanName, String attributeName, Object value) {
try {
MBeanServerConnection mBeanServerConnection = getJMXConnection();
ObjectName mbeanName = new ObjectName(mBeanName);
Attribute attr = new Attribute(attributeName, value);
mBeanServerConnection.setAttribute(mbeanName, attr);
} catch (Exception e) {
throw new RuntimeException(JMX_RETRIEVAL_ERROR + mBeanName + ": " + attributeName, e);
}
}
public void setSOAPSchemaValidationEnabled(boolean validationEnabled) {
setJMXMBeanAttributeValue("com.betfair.cougar.transport:type=soapCommandProcessor", "SchemaValidationEnabled", validationEnabled);
}
private Object getJMXMBeanAttributeValue(String mBeanName, String attributeName) {
try {
MBeanServerConnection mBeanServerConnection = getJMXConnection();
ObjectName mbeanName = new ObjectName(mBeanName);
return mBeanServerConnection.getAttribute(mbeanName, attributeName);
} catch (Exception e) {
throw new RuntimeException(JMX_RETRIEVAL_ERROR + mBeanName + ": " + attributeName, e);
}
}
private Object invokeJMXMBeanOperation(String mBeanName, String operationName, Object[] params,
String[] signature) {
try {
MBeanServerConnection mBeanServerConnection = getJMXConnection();
return mBeanServerConnection.invoke(new ObjectName(mBeanName), operationName, params, signature);
} catch (Exception e) {
throw new RuntimeException(JMX_INVOKE_ERROR + mBeanName + ": " + operationName +
" with arguments : " + Arrays.toString(params), e);
}
}
public String getJMXLoggingManagerAttributeValue(String attributeName) {
String mBeanName = "CoUGAR:name=Logging";
return getJMXMBeanAttributeValue(mBeanName, attributeName).toString();
}
public String getJMXApplicationPropertyValue(String key) {
String mBeanName = "CoUGAR:name=ApplicationProperties";
return (String) invokeJMXMBeanOperation(mBeanName, "getProperty",
new Object[]{key},
new String[]{"java.lang.String"});
}
public String getRuntimeAttributeValue(String attributeName){
String mBeanName = "java.lang:type=Runtime";
return getJMXMBeanAttributeValue(mBeanName, attributeName).toString();
}
public String getJMXAttributeValue(String mBeanName, String attributeName){
return getJMXMBeanAttributeValue(mBeanName, attributeName).toString();
}
/**
* Returns the system Java version string in the format usable for User-Agent field
* in cougar log
* @return String
*/
public String getJavaVersion() {
String s = "";
Pattern myPattern = Pattern.compile("(.*?)\\-");
Matcher m = myPattern.matcher(System.getProperty("java.runtime.version"));
while (m.find()) {
s = m.group(1);
}
return "\"Java/" + s + "\"";
}
public Map<String,String> convertFaultObjectToMap(HttpResponseBean soapResp){
DocumentImpl doc = (DocumentImpl) soapResp.getResponseObject();
String actualFaultCode = doc.getElementsByTagName("faultcode").item(0).getFirstChild().getNodeValue();
String actualFaultString = doc.getElementsByTagName("faultstring").item(0).getFirstChild().getNodeValue();
String actualMessage = doc.getElementsByTagName("message").item(0).getFirstChild().getNodeValue();
Node actualTraceNode = doc.getElementsByTagName("trace").item(0).getFirstChild();
String actualTrace = "";
if (actualTraceNode != null) {
actualTrace = actualTraceNode.getNodeValue();
actualTrace = actualTrace.replace("\r", ""); // Clean string of escaped characters (to avoid errors on Linux CI build)
actualTrace = actualTrace.trim();
}
Map<String,String> responseMap = new HashMap<String, String>();
responseMap.put("faultCode", actualFaultCode);
responseMap.put("faultString", actualFaultString);
responseMap.put("faultMessage", actualMessage);
responseMap.put("faultTrace", actualTrace);
return responseMap;
}
// Method to convert batched JSON response to a map for comparison (as the order of the array of responses cannot be relied upon)
public Map<String,Object> convertBatchedResponseToMap(HttpResponseBean batchedResponse) throws JSONException{
JSONObject json = (JSONObject) batchedResponse.getResponseObject();
JSONArray results = null;
try {
results = (JSONArray) json.get("response");
}
catch (JSONException je) {
logger.debug(String.valueOf(json),je);
throw je;
}
Map<String, Object> responseMap = new HashMap<String, Object >();
for(int i = 0; i < results.length(); i++){
String entryString = results.getString(i);
int idStart = entryString.indexOf(':')+1;
int idEnd = entryString.indexOf(',');
String id = entryString.substring(idStart, idEnd);
id = id.replace("\"","");
responseMap.put("response"+id, entryString);
}
responseMap.put("httpStatusCode",batchedResponse.getHttpStatusCode()+"");
responseMap.put("httpStatusText",batchedResponse.getHttpStatusText());
responseMap.put("requestTime", batchedResponse.getRequestTime());
responseMap.put("responseTime", batchedResponse.getResponseTime());
return responseMap;
}
public Date convertToSystemTimeZone(String datetoconvert)
{
TimeZone tz = TimeZone.getDefault();
Date date = new Date();
try{
DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
String s = datetoconvert;
String[] tmp = s.split(".0Z");
String s1= tmp[0];
logger.debug("given string is" +s1);
date = dateFormat.parse(s1);
logger.debug("OffsetValue is " +tz.getRawOffset());
if(tz.getRawOffset()!= 0)
date = new Date(date.getTime() + tz.getRawOffset());
logger.debug("After adding offset" +date);
if ( tz.inDaylightTime( date ))
{
Date dstDate = new Date( date.getTime() + tz.getDSTSavings() );
logger.debug("Day Light Saving is "+ tz.getDSTSavings());
logger.debug("Dst is "+ dstDate);
if ( tz.inDaylightTime( dstDate ))
{
date = dstDate;
// logger.debug("dst date "+ dstDate);
}
}
logger.debug("After the day light saving" +date);
}
catch(Exception e)
{
logger.debug("System exception caught" +e);
}
return date;
}
}