code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
private static TransportType map2TransportType(String transportId) {
TransportType type;
if (CXF_HTTP_TRANSPORT_ID.equals(transportId) || SOAP_HTTP_TRANSPORT_ID.equals(transportId)) {
type = TransportType.HTTP;
} else {
type = TransportType.OTHER;
}
return type;
} | java |
private EventTypeEnum getEventType(Message message) {
boolean isRequestor = MessageUtils.isRequestor(message);
boolean isFault = MessageUtils.isFault(message);
boolean isOutbound = MessageUtils.isOutbound(message);
//Needed because if it is rest request and method does not exists had better to return Fault
if(!isFault && isRestMessage(message)) {
isFault = (message.getExchange().get("org.apache.cxf.resource.operation.name") == null);
if (!isFault) {
Integer responseCode = (Integer) message.get(Message.RESPONSE_CODE);
if (null != responseCode) {
isFault = (responseCode >= 400);
}
}
}
if (isOutbound) {
if (isFault) {
return EventTypeEnum.FAULT_OUT;
} else {
return isRequestor ? EventTypeEnum.REQ_OUT : EventTypeEnum.RESP_OUT;
}
} else {
if (isFault) {
return EventTypeEnum.FAULT_IN;
} else {
return isRequestor ? EventTypeEnum.RESP_IN : EventTypeEnum.REQ_IN;
}
}
} | java |
protected String getPayload(Message message) {
try {
String encoding = (String) message.get(Message.ENCODING);
if (encoding == null) {
encoding = "UTF-8";
}
CachedOutputStream cos = message.getContent(CachedOutputStream.class);
if (cos == null) {
LOG.warning("Could not find CachedOutputStream in message."
+ " Continuing without message content");
return "";
}
return new String(cos.getBytes(), encoding);
} catch (IOException e) {
throw new RuntimeException(e);
}
} | java |
private void handleContentLength(Event event) {
if (event.getContent() == null) {
return;
}
if (maxContentLength == -1 || event.getContent().length() <= maxContentLength) {
return;
}
if (maxContentLength < CUT_START_TAG.length() + CUT_END_TAG.length()) {
event.setContent("");
event.setContentCut(true);
return;
}
int contentLength = maxContentLength - CUT_START_TAG.length() - CUT_END_TAG.length();
event.setContent(CUT_START_TAG + event.getContent().substring(0, contentLength) + CUT_END_TAG);
event.setContentCut(true);
} | java |
private Map<String, Criteria> getCriterias(Map<String, String[]> params) {
Map<String, Criteria> result = new HashMap<String, Criteria>();
for (Map.Entry<String, String[]> param : params.entrySet()) {
for (Criteria criteria : FILTER_CRITERIAS) {
if (criteria.getName().equals(param.getKey())) {
try {
Criteria[] parsedCriterias = criteria.parseValue(param.getValue()[0]);
for (Criteria parsedCriteria : parsedCriterias) {
result.put(parsedCriteria.getName(), parsedCriteria);
}
} catch (Exception e) {
// Exception happened during paring
LOG.log(Level.SEVERE, "Error parsing parameter " + param.getKey(), e);
}
break;
}
}
}
return result;
} | java |
public void setSessionTimeout(int timeout) {
((ZKBackend) getBackend()).setSessionTimeout(timeout);
if (LOG.isLoggable(Level.FINE)) {
LOG.fine("Locator session timeout set to: " + timeout);
}
} | java |
public void racRent() {
pos = pos - 1;
String userName = CarSearch.getLastSearchParams()[0];
String pickupDate = CarSearch.getLastSearchParams()[1];
String returnDate = CarSearch.getLastSearchParams()[2];
this.searcher.search(userName, pickupDate, returnDate);
if (searcher!=null && searcher.getCars()!= null && pos < searcher.getCars().size() && searcher.getCars().get(pos) != null) {
RESStatusType resStatus = reserver.reserveCar(searcher.getCustomer()
, searcher.getCars().get(pos)
, pickupDate
, returnDate);
ConfirmationType confirm = reserver.getConfirmation(resStatus
, searcher.getCustomer()
, searcher.getCars().get(pos)
, pickupDate
, returnDate);
RESCarType car = confirm.getCar();
CustomerDetailsType customer = confirm.getCustomer();
System.out.println(MessageFormat.format(CONFIRMATION
, confirm.getDescription()
, confirm.getReservationId()
, customer.getName()
, customer.getEmail()
, customer.getCity()
, customer.getStatus()
, car.getBrand()
, car.getDesignModel()
, confirm.getFromDate()
, confirm.getToDate()
, padl(car.getRateDay(), 10)
, padl(car.getRateWeekend(), 10)
, padl(confirm.getCreditPoints().toString(), 7)));
} else {
System.out.println("Invalid selection: " + (pos+1)); //$NON-NLS-1$
}
} | java |
public void addProperty(String name, String... values) {
List<String> valueList = new ArrayList<String>();
for (String value : values) {
valueList.add(value.trim());
}
properties.put(name.trim(), valueList);
} | java |
protected SingleBusLocatorRegistrar getRegistrar(Bus bus) {
SingleBusLocatorRegistrar registrar = busRegistrars.get(bus);
if (registrar == null) {
check(locatorClient, "serviceLocator", "registerService");
registrar = new SingleBusLocatorRegistrar(bus);
registrar.setServiceLocator(locatorClient);
registrar.setEndpointPrefix(endpointPrefix);
Map<String, String> endpointPrefixes = new HashMap<String, String>();
endpointPrefixes.put("HTTP", endpointPrefixHttp);
endpointPrefixes.put("HTTPS", endpointPrefixHttps);
registrar.setEndpointPrefixes(endpointPrefixes);
busRegistrars.put(bus, registrar);
addLifeCycleListener(bus);
}
return registrar;
} | java |
public void useXopAttachmentServiceWithWebClient() throws Exception {
final String serviceURI = "http://localhost:" + port + "/services/attachments/xop";
JAXRSClientFactoryBean factoryBean = new JAXRSClientFactoryBean();
factoryBean.setAddress(serviceURI);
factoryBean.setProperties(Collections.singletonMap(org.apache.cxf.message.Message.MTOM_ENABLED,
(Object)"true"));
WebClient client = factoryBean.createWebClient();
WebClient.getConfig(client).getRequestContext().put("support.type.as.multipart",
"true");
client.type("multipart/related").accept("multipart/related");
XopBean xop = createXopBean();
System.out.println();
System.out.println("Posting a XOP attachment with a WebClient");
XopBean xopResponse = client.post(xop, XopBean.class);
verifyXopResponse(xop, xopResponse);
} | java |
public void useXopAttachmentServiceWithProxy() throws Exception {
final String serviceURI = "http://localhost:" + port + "/services/attachments";
XopAttachmentService proxy = JAXRSClientFactory.create(serviceURI,
XopAttachmentService.class);
XopBean xop = createXopBean();
System.out.println();
System.out.println("Posting a XOP attachment with a proxy");
XopBean xopResponse = proxy.echoXopAttachment(xop);
verifyXopResponse(xop, xopResponse);
} | java |
private XopBean createXopBean() throws Exception {
XopBean xop = new XopBean();
xop.setName("xopName");
InputStream is = getClass().getResourceAsStream("/java.jpg");
byte[] data = IOUtils.readBytesFromStream(is);
// Pass java.jpg as an array of bytes
xop.setBytes(data);
// Wrap java.jpg as a DataHandler
xop.setDatahandler(new DataHandler(
new ByteArrayDataSource(data, "application/octet-stream")));
if (Boolean.getBoolean("java.awt.headless")) {
System.out.println("Running headless. Ignoring an Image property.");
} else {
xop.setImage(getImage("/java.jpg"));
}
return xop;
} | java |
private void verifyXopResponse(XopBean xopOriginal, XopBean xopResponse) {
if (!Arrays.equals(xopResponse.getBytes(), xopOriginal.getBytes())) {
throw new RuntimeException("Received XOP attachment is corrupted");
}
System.out.println();
System.out.println("XOP attachment has been successfully received");
} | java |
public void setMonitoringService(org.talend.esb.sam.common.service.MonitoringService monitoringService) {
this.monitoringService = monitoringService;
} | java |
private static void throwFault(String code, String message, Throwable t) throws PutEventsFault {
if (LOG.isLoggable(Level.SEVERE)) {
LOG.log(Level.SEVERE, "Throw Fault " + code + " " + message, t);
}
FaultType faultType = new FaultType();
faultType.setFaultCode(code);
faultType.setFaultMessage(message);
StringWriter stringWriter = new StringWriter();
PrintWriter printWriter = new PrintWriter(stringWriter);
t.printStackTrace(printWriter);
faultType.setStackTrace(stringWriter.toString());
throw new PutEventsFault(message, faultType, t);
} | java |
public void putEvents(List<Event> events) {
Exception lastException;
List<EventType> eventTypes = new ArrayList<EventType>();
for (Event event : events) {
EventType eventType = EventMapper.map(event);
eventTypes.add(eventType);
}
int i = 0;
lastException = null;
while (i < numberOfRetries) {
try {
monitoringService.putEvents(eventTypes);
break;
} catch (Exception e) {
lastException = e;
i++;
}
if(i < numberOfRetries) {
try {
Thread.sleep(delayBetweenRetry);
} catch (InterruptedException e) {
break;
}
}
}
if (i == numberOfRetries) {
throw new MonitoringException("1104", "Could not send events to monitoring service after "
+ numberOfRetries + " retries.", lastException, events);
}
} | java |
private EventType createEventType(EventEnumType type) {
EventType eventType = new EventType();
eventType.setTimestamp(Converter.convertDate(new Date()));
eventType.setEventType(type);
OriginatorType origType = new OriginatorType();
origType.setProcessId(Converter.getPID());
try {
InetAddress inetAddress = InetAddress.getLocalHost();
origType.setIp(inetAddress.getHostAddress());
origType.setHostname(inetAddress.getHostName());
} catch (UnknownHostException e) {
origType.setHostname("Unknown hostname");
origType.setIp("Unknown ip address");
}
eventType.setOriginator(origType);
String path = System.getProperty("karaf.home");
CustomInfoType ciType = new CustomInfoType();
CustomInfoType.Item cItem = new CustomInfoType.Item();
cItem.setKey("path");
cItem.setValue(path);
ciType.getItem().add(cItem);
eventType.setCustomInfo(ciType);
return eventType;
} | java |
private void putEvent(EventType eventType) throws Exception {
List<EventType> eventTypes = Collections.singletonList(eventType);
int i;
for (i = 0; i < retryNum; ++i) {
try {
monitoringService.putEvents(eventTypes);
break;
} catch (Exception e) {
LOG.log(Level.SEVERE, e.getMessage(), e);
}
Thread.sleep(retryDelay);
}
if (i == retryNum) {
LOG.warning("Could not send events to monitoring service after " + retryNum + " retries.");
throw new Exception("Send SERVER_START/SERVER_STOP event to SAM Server failed");
}
} | java |
private boolean checkConfig(BundleContext context) throws Exception {
ServiceReference serviceRef = context.getServiceReference(ConfigurationAdmin.class.getName());
ConfigurationAdmin cfgAdmin = (ConfigurationAdmin)context.getService(serviceRef);
Configuration config = cfgAdmin.getConfiguration("org.talend.esb.sam.agent");
return "true".equalsIgnoreCase((String)config.getProperties().get("collector.lifecycleEvent"));
} | java |
private void initWsClient(BundleContext context) throws Exception {
ServiceReference serviceRef = context.getServiceReference(ConfigurationAdmin.class.getName());
ConfigurationAdmin cfgAdmin = (ConfigurationAdmin)context.getService(serviceRef);
Configuration config = cfgAdmin.getConfiguration("org.talend.esb.sam.agent");
String serviceURL = (String)config.getProperties().get("service.url");
retryNum = Integer.parseInt((String)config.getProperties().get("service.retry.number"));
retryDelay = Long.parseLong((String)config.getProperties().get("service.retry.delay"));
JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();
factory.setServiceClass(org.talend.esb.sam.monitoringservice.v1.MonitoringService.class);
factory.setAddress(serviceURL);
monitoringService = (MonitoringService)factory.create();
} | java |
protected void handleResponseOut(T message) throws Fault {
Message reqMsg = message.getExchange().getInMessage();
if (reqMsg == null) {
LOG.warning("InMessage is null!");
return;
}
// No flowId for oneway message
Exchange ex = reqMsg.getExchange();
if (ex.isOneWay()) {
return;
}
String reqFid = FlowIdHelper.getFlowId(reqMsg);
// if some interceptor throws fault before FlowIdProducerIn fired
if (reqFid == null) {
if (LOG.isLoggable(Level.FINE)) {
LOG.fine("Some interceptor throws fault.Setting FlowId in response.");
}
reqFid = FlowIdProtocolHeaderCodec.readFlowId(message);
}
// write IN message to SAM repo in case fault
if (reqFid == null) {
Message inMsg = ex.getInMessage();
reqFid = FlowIdProtocolHeaderCodec.readFlowId(inMsg);
if (null != reqFid) {
if (LOG.isLoggable(Level.FINE)) {
LOG.fine("FlowId '" + reqFid
+ "' found in message of fault incoming exchange.");
LOG.fine("Calling EventProducerInterceptor to log IN message");
}
handleINEvent(ex, reqFid);
}
}
if (reqFid == null) {
reqFid = FlowIdSoapCodec.readFlowId(message);
}
if (reqFid != null) {
if (LOG.isLoggable(Level.FINE)) {
LOG.fine("FlowId '" + reqFid + "' found in incoming message.");
}
} else {
reqFid = ContextUtils.generateUUID();
// write IN message to SAM repo in case fault
if (null != ex.getOutFaultMessage()) {
if (LOG.isLoggable(Level.FINE)) {
LOG.fine("FlowId '" + reqFid
+ "' generated for fault message.");
LOG.fine("Calling EventProducerInterceptor to log IN message");
}
handleINEvent(ex, reqFid);
}
if (LOG.isLoggable(Level.FINE)) {
LOG.fine("No flowId found in incoming message! Generate new flowId "
+ reqFid);
}
}
FlowIdHelper.setFlowId(message, reqFid);
} | java |
protected void handleRequestOut(T message) throws Fault {
String flowId = FlowIdHelper.getFlowId(message);
if (flowId == null
&& message.containsKey(PhaseInterceptorChain.PREVIOUS_MESSAGE)) {
// Web Service consumer is acting as an intermediary
@SuppressWarnings("unchecked")
WeakReference<Message> wrPreviousMessage = (WeakReference<Message>) message
.get(PhaseInterceptorChain.PREVIOUS_MESSAGE);
Message previousMessage = (Message) wrPreviousMessage.get();
flowId = FlowIdHelper.getFlowId(previousMessage);
if (flowId != null && LOG.isLoggable(Level.FINE)) {
LOG.fine("flowId '" + flowId + "' found in previous message");
}
}
if (flowId == null) {
// No flowId found. Generate one.
flowId = ContextUtils.generateUUID();
if (LOG.isLoggable(Level.FINE)) {
LOG.fine("Generate new flowId '" + flowId + "'");
}
}
FlowIdHelper.setFlowId(message, flowId);
} | java |
protected void handleINEvent(Exchange exchange, String reqFid) throws Fault {
Message inMsg = exchange.getInMessage();
EventProducerInterceptor epi = null;
FlowIdHelper.setFlowId(inMsg, reqFid);
ListIterator<Interceptor<? extends Message>> interceptors = inMsg
.getInterceptorChain().getIterator();
while (interceptors.hasNext() && epi == null) {
Interceptor<? extends Message> interceptor = interceptors.next();
if (interceptor instanceof EventProducerInterceptor) {
epi = (EventProducerInterceptor) interceptor;
epi.handleMessage(inMsg);
}
}
} | java |
public void setDialect(String dialect) {
String[] scripts = createScripts.get(dialect);
createSql = scripts[0];
createSqlInd = scripts[1];
} | java |
public static Event map(EventType eventType) {
Event event = new Event();
event.setEventType(mapEventTypeEnum(eventType.getEventType()));
Date date = (eventType.getTimestamp() == null)
? new Date() : eventType.getTimestamp().toGregorianCalendar().getTime();
event.setTimestamp(date);
event.setOriginator(mapOriginatorType(eventType.getOriginator()));
MessageInfo messageInfo = mapMessageInfo(eventType.getMessageInfo());
event.setMessageInfo(messageInfo);
String content = mapContent(eventType.getContent());
event.setContent(content);
event.getCustomInfo().clear();
event.getCustomInfo().putAll(mapCustomInfo(eventType.getCustomInfo()));
return event;
} | java |
private static Map<String, String> mapCustomInfo(CustomInfoType ciType){
Map<String, String> customInfo = new HashMap<String, String>();
if (ciType != null){
for (CustomInfoType.Item item : ciType.getItem()) {
customInfo.put(item.getKey(), item.getValue());
}
}
return customInfo;
} | java |
private static String mapContent(DataHandler dh) {
if (dh == null) {
return "";
}
try {
InputStream is = dh.getInputStream();
String content = IOUtils.toString(is);
is.close();
return content;
} catch (IOException e) {
throw new RuntimeException(e);
}
} | java |
private static MessageInfo mapMessageInfo(MessageInfoType messageInfoType) {
MessageInfo messageInfo = new MessageInfo();
if (messageInfoType != null) {
messageInfo.setFlowId(messageInfoType.getFlowId());
messageInfo.setMessageId(messageInfoType.getMessageId());
messageInfo.setOperationName(messageInfoType.getOperationName());
messageInfo.setPortType(messageInfoType.getPorttype() == null
? "" : messageInfoType.getPorttype().toString());
messageInfo.setTransportType(messageInfoType.getTransport());
}
return messageInfo;
} | java |
private static Originator mapOriginatorType(OriginatorType originatorType) {
Originator originator = new Originator();
if (originatorType != null) {
originator.setCustomId(originatorType.getCustomId());
originator.setHostname(originatorType.getHostname());
originator.setIp(originatorType.getIp());
originator.setProcessId(originatorType.getProcessId());
originator.setPrincipal(originatorType.getPrincipal());
}
return originator;
} | java |
private static EventTypeEnum mapEventTypeEnum(EventEnumType eventType) {
if (eventType != null) {
return EventTypeEnum.valueOf(eventType.name());
}
return EventTypeEnum.UNKNOWN;
} | java |
public void useNewSOAPService(boolean direct) throws Exception {
URL wsdlURL = getClass().getResource("/CustomerServiceNew.wsdl");
org.customer.service.CustomerServiceService service =
new org.customer.service.CustomerServiceService(wsdlURL);
org.customer.service.CustomerService customerService =
direct ? service.getCustomerServicePort() : service.getCustomerServiceNewPort();
System.out.println("Using new SOAP CustomerService with new client");
customer.v2.Customer customer = createNewCustomer("Barry New SOAP");
customerService.updateCustomer(customer);
customer = customerService.getCustomerByName("Barry New SOAP");
printNewCustomerDetails(customer);
} | java |
public void useNewSOAPServiceWithOldClient() throws Exception {
URL wsdlURL = getClass().getResource("/CustomerServiceNew.wsdl");
com.example.customerservice.CustomerServiceService service =
new com.example.customerservice.CustomerServiceService(wsdlURL);
com.example.customerservice.CustomerService customerService =
service.getCustomerServicePort();
// The outgoing new Customer data needs to be transformed for
// the old service to understand it and the response from the old service
// needs to be transformed for this new client to understand it.
Client client = ClientProxy.getClient(customerService);
addTransformInterceptors(client.getInInterceptors(),
client.getOutInterceptors(),
false);
System.out.println("Using new SOAP CustomerService with old client");
customer.v1.Customer customer = createOldCustomer("Barry Old to New SOAP");
customerService.updateCustomer(customer);
customer = customerService.getCustomerByName("Barry Old to New SOAP");
printOldCustomerDetails(customer);
} | java |
public void useNewSOAPServiceWithOldClientAndRedirection() throws Exception {
URL wsdlURL = getClass().getResource("/CustomerService.wsdl");
com.example.customerservice.CustomerServiceService service =
new com.example.customerservice.CustomerServiceService(wsdlURL);
com.example.customerservice.CustomerService customerService =
service.getCustomerServiceRedirectPort();
System.out.println("Using new SOAP CustomerService with old client and the redirection");
customer.v1.Customer customer = createOldCustomer("Barry Old to New SOAP With Redirection");
customerService.updateCustomer(customer);
customer = customerService.getCustomerByName("Barry Old to New SOAP With Redirection");
printOldCustomerDetails(customer);
} | java |
private void addTransformInterceptors(List<Interceptor<?>> inInterceptors,
List<Interceptor<?>> outInterceptors,
boolean newClient) {
// The old service expects the Customer data be qualified with
// the 'http://customer/v1' namespace.
// The new service expects the Customer data be qualified with
// the 'http://customer/v2' namespace.
// If it is an old client talking to the new service then:
// - the out transformation interceptor is configured for
// 'http://customer/v1' qualified data be transformed into
// 'http://customer/v2' qualified data.
// - the in transformation interceptor is configured for
// 'http://customer/v2' qualified response data be transformed into
// 'http://customer/v1' qualified data.
// If it is a new client talking to the old service then:
// - the out transformation interceptor is configured for
// 'http://customer/v2' qualified data be transformed into
// 'http://customer/v1' qualified data.
// - the in transformation interceptor is configured for
// 'http://customer/v1' qualified response data be transformed into
// 'http://customer/v2' qualified data.
// - new Customer type also introduces a briefDescription property
// which needs to be dropped for the old service validation to succeed
// this configuration can be provided externally
Map<String, String> newToOldTransformMap = new HashMap<String, String>();
newToOldTransformMap.put("{http://customer/v2}*", "{http://customer/v1}*");
Map<String, String> oldToNewTransformMap =
Collections.singletonMap("{http://customer/v1}*", "{http://customer/v2}*");
TransformOutInterceptor outTransform = new TransformOutInterceptor();
outTransform.setOutTransformElements(newClient ? newToOldTransformMap
: oldToNewTransformMap);
if (newClient) {
newToOldTransformMap.put("{http://customer/v2}briefDescription", "");
//outTransform.setOutDropElements(
// Collections.singletonList("{http://customer/v2}briefDescription"));
}
TransformInInterceptor inTransform = new TransformInInterceptor();
inTransform.setInTransformElements(newClient ? oldToNewTransformMap
: newToOldTransformMap);
inInterceptors.add(inTransform);
outInterceptors.add(outTransform);
} | java |
@SuppressWarnings("unused")
@XmlID
@XmlAttribute(name = "id")
private String getXmlID(){
return String.format("%s-%s", this.getClass().getSimpleName(), Long.valueOf(id));
} | java |
private void stopAllServersAndRemoveCamelContext(CamelContext camelContext) {
log.debug("Stopping all servers associated with {}", camelContext);
List<SingleBusLocatorRegistrar> registrars = locatorRegistrar.getAllRegistars(camelContext);
registrars.forEach(registrar -> registrar.stopAllServersAndRemoveCamelContext());
} | java |
public static EventType map(Event event) {
EventType eventType = new EventType();
eventType.setTimestamp(Converter.convertDate(event.getTimestamp()));
eventType.setEventType(convertEventType(event.getEventType()));
OriginatorType origType = mapOriginator(event.getOriginator());
eventType.setOriginator(origType);
MessageInfoType miType = mapMessageInfo(event.getMessageInfo());
eventType.setMessageInfo(miType);
eventType.setCustomInfo(convertCustomInfo(event.getCustomInfo()));
eventType.setContentCut(event.isContentCut());
if (event.getContent() != null) {
DataHandler datHandler = getDataHandlerForString(event);
eventType.setContent(datHandler);
}
return eventType;
} | java |
private static DataHandler getDataHandlerForString(Event event) {
try {
return new DataHandler(new ByteDataSource(event.getContent().getBytes("UTF-8")));
} catch (UnsupportedEncodingException e) {
throw new RuntimeException(e);
}
} | java |
private static MessageInfoType mapMessageInfo(MessageInfo messageInfo) {
if (messageInfo == null) {
return null;
}
MessageInfoType miType = new MessageInfoType();
miType.setMessageId(messageInfo.getMessageId());
miType.setFlowId(messageInfo.getFlowId());
miType.setPorttype(convertString(messageInfo.getPortType()));
miType.setOperationName(messageInfo.getOperationName());
miType.setTransport(messageInfo.getTransportType());
return miType;
} | java |
private static OriginatorType mapOriginator(Originator originator) {
if (originator == null) {
return null;
}
OriginatorType origType = new OriginatorType();
origType.setProcessId(originator.getProcessId());
origType.setIp(originator.getIp());
origType.setHostname(originator.getHostname());
origType.setCustomId(originator.getCustomId());
origType.setPrincipal(originator.getPrincipal());
return origType;
} | java |
private static CustomInfoType convertCustomInfo(Map<String, String> customInfo) {
if (customInfo == null) {
return null;
}
CustomInfoType ciType = new CustomInfoType();
for (Entry<String, String> entry : customInfo.entrySet()) {
CustomInfoType.Item cItem = new CustomInfoType.Item();
cItem.setKey(entry.getKey());
cItem.setValue(entry.getValue());
ciType.getItem().add(cItem);
}
return ciType;
} | java |
private static EventEnumType convertEventType(org.talend.esb.sam.common.event.EventTypeEnum eventType) {
if (eventType == null) {
return null;
}
return EventEnumType.valueOf(eventType.name());
} | java |
private static QName convertString(String str) {
if (str != null) {
return QName.valueOf(str);
} else {
return null;
}
} | java |
public void logException(Level level) {
if (!LOG.isLoggable(level)) {
return;
}
final StringBuilder builder = new StringBuilder();
builder.append("\n----------------------------------------------------");
builder.append("\nMonitoringException");
builder.append("\n----------------------------------------------------");
builder.append("\nCode: ").append(code);
builder.append("\nMessage: ").append(message);
builder.append("\n----------------------------------------------------");
if (events != null) {
for (Event event : events) {
builder.append("\nEvent:");
if (event.getMessageInfo() != null) {
builder.append("\nMessage id: ").append(event.getMessageInfo().getMessageId());
builder.append("\nFlow id: ").append(event.getMessageInfo().getFlowId());
builder.append("\n----------------------------------------------------");
} else {
builder.append("\nNo message id and no flow id");
}
}
}
builder.append("\n----------------------------------------------------\n");
LOG.log(level, builder.toString(), this);
} | java |
private LocatorSelectionStrategy getLocatorSelectionStrategy(String locatorSelectionStrategy) {
if (null == locatorSelectionStrategy) {
return locatorSelectionStrategyMap.get(DEFAULT_STRATEGY).getInstance();
}
if (LOG.isLoggable(Level.FINE)) {
LOG.log(Level.FINE, "Strategy " + locatorSelectionStrategy
+ " was set for LocatorClientRegistrar.");
}
if (locatorSelectionStrategyMap.containsKey(locatorSelectionStrategy)) {
return locatorSelectionStrategyMap.get(locatorSelectionStrategy).getInstance();
} else {
if (LOG.isLoggable(Level.WARNING)) {
LOG.log(Level.WARNING, "LocatorSelectionStrategy " + locatorSelectionStrategy
+ " not registered at LocatorClientEnabler.");
}
return locatorSelectionStrategyMap.get(DEFAULT_STRATEGY).getInstance();
}
} | java |
@Value("${locator.strategy}")
public void setDefaultLocatorSelectionStrategy(String defaultLocatorSelectionStrategy) {
this.defaultLocatorSelectionStrategy = defaultLocatorSelectionStrategy;
if (LOG.isLoggable(Level.FINE)) {
LOG.log(Level.FINE, "Default strategy " + defaultLocatorSelectionStrategy
+ " was set for LocatorClientRegistrar.");
}
} | java |
public void enable(ConduitSelectorHolder conduitSelectorHolder, SLPropertiesMatcher matcher,
String selectionStrategy) {
LocatorTargetSelector selector = new LocatorTargetSelector();
selector.setEndpoint(conduitSelectorHolder.getConduitSelector().getEndpoint());
String actualStrategy = selectionStrategy != null ? selectionStrategy : defaultLocatorSelectionStrategy;
LocatorSelectionStrategy locatorSelectionStrategy = getLocatorSelectionStrategy(actualStrategy);
locatorSelectionStrategy.setServiceLocator(locatorClient);
if (matcher != null) {
locatorSelectionStrategy.setMatcher(matcher);
}
selector.setLocatorSelectionStrategy(locatorSelectionStrategy);
if (LOG.isLoggable(Level.INFO)) {
LOG.log(Level.INFO, "Client enabled with strategy "
+ locatorSelectionStrategy.getClass().getName() + ".");
}
conduitSelectorHolder.setConduitSelector(selector);
if (LOG.isLoggable(Level.FINE)) {
LOG.log(Level.FINE, "Successfully enabled client " + conduitSelectorHolder
+ " for the service locator");
}
} | java |
public static void applyWsdlExtensions(Bus bus) {
ExtensionRegistry registry = bus.getExtension(WSDLManager.class).getExtensionRegistry();
try {
JAXBExtensionHelper.addExtensions(registry,
javax.wsdl.Definition.class,
org.talend.esb.mep.requestcallback.impl.wsdl.PLType.class);
JAXBExtensionHelper.addExtensions(registry,
javax.wsdl.Binding.class,
org.talend.esb.mep.requestcallback.impl.wsdl.CallbackExtension.class);
} catch (JAXBException e) {
throw new RuntimeException("Failed to add WSDL JAXB extensions", e);
}
} | java |
@Inject
public void setQueue(EventQueue queue) {
if (epi == null) {
MessageToEventMapper mapper = new MessageToEventMapper();
mapper.setMaxContentLength(maxContentLength);
epi = new EventProducerInterceptor(mapper, queue);
}
} | java |
private boolean detectWSAddressingFeature(InterceptorProvider provider, Bus bus) {
//detect on the bus level
if (bus.getFeatures() != null) {
Iterator<Feature> busFeatures = bus.getFeatures().iterator();
while (busFeatures.hasNext()) {
Feature busFeature = busFeatures.next();
if (busFeature instanceof WSAddressingFeature) {
return true;
}
}
}
//detect on the endpoint/client level
Iterator<Interceptor<? extends Message>> interceptors = provider.getInInterceptors().iterator();
while (interceptors.hasNext()) {
Interceptor<? extends Message> ic = interceptors.next();
if (ic instanceof MAPAggregator) {
return true;
}
}
return false;
} | java |
private void addWSAddressingInterceptors(InterceptorProvider provider) {
MAPAggregator mapAggregator = new MAPAggregator();
MAPCodec mapCodec = new MAPCodec();
provider.getInInterceptors().add(mapAggregator);
provider.getInInterceptors().add(mapCodec);
provider.getOutInterceptors().add(mapAggregator);
provider.getOutInterceptors().add(mapCodec);
provider.getInFaultInterceptors().add(mapAggregator);
provider.getInFaultInterceptors().add(mapCodec);
provider.getOutFaultInterceptors().add(mapAggregator);
provider.getOutFaultInterceptors().add(mapCodec);
} | java |
public static String readFlowId(Message message) {
if (!(message instanceof SoapMessage)) {
return null;
}
String flowId = null;
Header hdFlowId = ((SoapMessage)message).getHeader(FLOW_ID_QNAME);
if (hdFlowId != null) {
if (hdFlowId.getObject() instanceof String) {
flowId = (String)hdFlowId.getObject();
} else if (hdFlowId.getObject() instanceof Node) {
Node headerNode = (Node)hdFlowId.getObject();
flowId = headerNode.getTextContent();
} else {
LOG.warning("Found FlowId soap header but value is not a String or a Node! Value: "
+ hdFlowId.getObject().toString());
}
}
return flowId;
} | java |
public static void writeFlowId(Message message, String flowId) {
if (!(message instanceof SoapMessage)) {
return;
}
SoapMessage soapMessage = (SoapMessage)message;
Header hdFlowId = soapMessage.getHeader(FLOW_ID_QNAME);
if (hdFlowId != null) {
LOG.warning("FlowId already existing in soap header, need not to write FlowId header.");
return;
}
try {
soapMessage.getHeaders().add(
new Header(FLOW_ID_QNAME, flowId, new JAXBDataBinding(String.class)));
if (LOG.isLoggable(Level.FINE)) {
LOG.fine("Stored flowId '" + flowId + "' in soap header: " + FLOW_ID_QNAME);
}
} catch (JAXBException e) {
LOG.log(Level.SEVERE, "Couldn't create flowId header.", e);
}
} | java |
public static STSClient createSTSX509Client(Bus bus, Map<String, String> stsProps) {
final STSClient stsClient = createClient(bus, stsProps);
stsClient.setWsdlLocation(stsProps.get(STS_X509_WSDL_LOCATION));
stsClient.setEndpointQName(new QName(stsProps.get(STS_NAMESPACE), stsProps.get(STS_X509_ENDPOINT_NAME)));
return stsClient;
} | java |
private boolean isSecuredByPolicy(Server server) {
boolean isSecured = false;
EndpointInfo ei = server.getEndpoint().getEndpointInfo();
PolicyEngine pe = bus.getExtension(PolicyEngine.class);
if (null == pe) {
LOG.finest("No Policy engine found");
return isSecured;
}
Destination destination = server.getDestination();
EndpointPolicy ep = pe.getServerEndpointPolicy(ei, destination, null);
Collection<Assertion> assertions = ep.getChosenAlternative();
for (Assertion a : assertions) {
if (a instanceof TransportBinding) {
TransportBinding tb = (TransportBinding) a;
TransportToken tt = tb.getTransportToken();
AbstractToken t = tt.getToken();
if (t instanceof HttpsToken) {
isSecured = true;
break;
}
}
}
Policy policy = ep.getPolicy();
List<PolicyComponent> pcList = policy.getPolicyComponents();
for (PolicyComponent a : pcList) {
if (a instanceof TransportBinding) {
TransportBinding tb = (TransportBinding) a;
TransportToken tt = tb.getTransportToken();
AbstractToken t = tt.getToken();
if (t instanceof HttpsToken) {
isSecured = true;
break;
}
}
}
return isSecured;
} | java |
private boolean isSecuredByProperty(Server server) {
boolean isSecured = false;
Object value = server.getEndpoint().get("org.talend.tesb.endpoint.secured"); //Property name TBD
if (value instanceof String) {
try {
isSecured = Boolean.valueOf((String) value);
} catch (Exception ex) {
}
}
return isSecured;
} | java |
private void writeCustomInfo(Event event) {
// insert customInfo (key/value) into DB
for (Map.Entry<String, String> customInfo : event.getCustomInfo().entrySet()) {
long cust_id = dbDialect.getIncrementer().nextLongValue();
getJdbcTemplate()
.update("insert into EVENTS_CUSTOMINFO (ID, EVENT_ID, CUST_KEY, CUST_VALUE)"
+ " values (?,?,?,?)",
cust_id, event.getPersistedId(), customInfo.getKey(), customInfo.getValue());
}
} | java |
private Map<String, String> readCustomInfo(long eventId) {
List<Map<String, Object>> rows = getJdbcTemplate()
.queryForList("select * from EVENTS_CUSTOMINFO where EVENT_ID=" + eventId);
Map<String, String> customInfo = new HashMap<String, String>(rows.size());
for (Map<String, Object> row : rows) {
customInfo.put((String)row.get("CUST_KEY"), (String)row.get("CUST_VALUE"));
}
return customInfo;
} | java |
private String toSQLPattern(String attribute) {
String pattern = attribute.replace("*", "%");
if (!pattern.startsWith("%")) {
pattern = "%" + pattern;
}
if (!pattern.endsWith("%")) {
pattern = pattern.concat("%");
}
return pattern;
} | java |
private void checkMessageID(Message message) {
if (!MessageUtils.isOutbound(message)) return;
AddressingProperties maps =
ContextUtils.retrieveMAPs(message, false, MessageUtils.isOutbound(message));
if (maps == null) {
maps = new AddressingProperties();
}
if (maps.getMessageID() == null) {
String messageID = ContextUtils.generateUUID();
boolean isRequestor = ContextUtils.isRequestor(message);
maps.setMessageID(ContextUtils.getAttributedURI(messageID));
ContextUtils.storeMAPs(maps, message, ContextUtils.isOutbound(message), isRequestor);
}
} | java |
public static String getCorrelationId(Message message) {
String correlationId = (String) message.get(CORRELATION_ID_KEY);
if(null == correlationId) {
correlationId = readCorrelationId(message);
}
if(null == correlationId) {
correlationId = readCorrelationIdSoap(message);
}
return correlationId;
} | java |
public static String readCorrelationId(Message message) {
String correlationId = null;
Map<String, List<String>> headers = getOrCreateProtocolHeader(message);
List<String> correlationIds = headers.get(CORRELATION_ID_KEY);
if (correlationIds != null && correlationIds.size() > 0) {
correlationId = correlationIds.get(0);
if (LOG.isLoggable(Level.FINE)) {
LOG.fine("HTTP header '" + CORRELATION_ID_KEY + "' found: " + correlationId);
}
} else {
if (LOG.isLoggable(Level.FINE)) {
LOG.fine("No HTTP header '" + CORRELATION_ID_KEY + "' found");
}
}
return correlationId;
} | java |
private static Map<String, List<String>> getOrCreateProtocolHeader(
Message message) {
Map<String, List<String>> headers = CastUtils.cast((Map<?, ?>) message
.get(Message.PROTOCOL_HEADERS));
if (headers == null) {
headers = new HashMap<String, List<String>>();
message.put(Message.PROTOCOL_HEADERS, headers);
}
return headers;
} | java |
public void putEvents(List<Event> events) {
List<Event> filteredEvents = filterEvents(events);
executeHandlers(filteredEvents);
for (Event event : filteredEvents) {
persistenceHandler.writeEvent(event);
}
} | java |
private List<Event> filterEvents(List<Event> events) {
List<Event> filteredEvents = new ArrayList<Event>();
for (Event event : events) {
if (!filter(event)) {
filteredEvents.add(event);
}
}
return filteredEvents;
} | java |
public boolean filter(Event event) {
LOG.info("StringContentFilter called");
if (wordsToFilter != null) {
for (String filterWord : wordsToFilter) {
if (event.getContent() != null
&& -1 != event.getContent().indexOf(filterWord)) {
return true;
}
}
}
return false;
} | java |
public String checkIn(byte[] data) {
String id = UUID.randomUUID().toString();
dataMap.put(id, data);
return id;
} | java |
private static void setupFlowId(SoapMessage message) {
String flowId = FlowIdHelper.getFlowId(message);
if (flowId == null) {
flowId = FlowIdProtocolHeaderCodec.readFlowId(message);
}
if (flowId == null) {
flowId = FlowIdSoapCodec.readFlowId(message);
}
if (flowId == null) {
Exchange ex = message.getExchange();
if (null!=ex){
Message reqMsg = ex.getOutMessage();
if ( null != reqMsg) {
flowId = FlowIdHelper.getFlowId(reqMsg);
}
}
}
if (flowId != null && !flowId.isEmpty()) {
FlowIdHelper.setFlowId(message, flowId);
}
} | java |
private static X509Certificate getReqSigCert(Message message) {
List<WSHandlerResult> results =
CastUtils.cast((List<?>)
message.getExchange().getInMessage().get(WSHandlerConstants.RECV_RESULTS));
if (results == null) {
return null;
}
/*
* Scan the results for a matching actor. Use results only if the
* receiving Actor and the sending Actor match.
*/
for (WSHandlerResult rResult : results) {
List<WSSecurityEngineResult> wsSecEngineResults = rResult
.getResults();
/*
* Scan the results for the first Signature action. Use the
* certificate of this Signature to set the certificate for the
* encryption action :-).
*/
for (WSSecurityEngineResult wser : wsSecEngineResults) {
Integer actInt = (Integer) wser
.get(WSSecurityEngineResult.TAG_ACTION);
if (actInt.intValue() == WSConstants.SIGN) {
return (X509Certificate) wser
.get(WSSecurityEngineResult.TAG_X509_CERTIFICATE);
}
}
}
return null;
} | java |
private void useSearchService() throws Exception {
System.out.println("Searching...");
WebClient wc = WebClient.create("http://localhost:" + port + "/services/personservice/search");
WebClient.getConfig(wc).getHttpConduit().getClient().setReceiveTimeout(10000000L);
wc.accept(MediaType.APPLICATION_XML);
// Moves to "/services/personservice/search"
wc.path("person");
SearchConditionBuilder builder = SearchConditionBuilder.instance();
System.out.println("Find people with the name Fred or Lorraine:");
String query = builder.is("name").equalTo("Fred").or()
.is("name").equalTo("Lorraine")
.query();
findPersons(wc, query);
System.out.println("Find all people who are no more than 30 years old");
query = builder.is("age").lessOrEqualTo(30)
.query();
findPersons(wc, query);
System.out.println("Find all people who are older than 28 and whose father name is John");
query = builder.is("age").greaterThan(28)
.and("fatherName").equalTo("John")
.query();
findPersons(wc, query);
System.out.println("Find all people who have children with name Fred");
query = builder.is("childName").equalTo("Fred")
.query();
findPersons(wc, query);
//Moves to "/services/personservice/personinfo"
wc.reset().accept(MediaType.APPLICATION_XML);
wc.path("personinfo");
System.out.println("Find all people younger than 40 using JPA2 Tuples");
query = builder.is("age").lessThan(40).query();
// Use URI path component to capture the query expression
wc.path(query);
Collection<? extends PersonInfo> personInfos = wc.getCollection(PersonInfo.class);
for (PersonInfo pi : personInfos) {
System.out.println("ID : " + pi.getId());
}
wc.close();
} | java |
public void useSimpleProxy() {
String webAppAddress = "http://localhost:" + port + "/services/personservice";
PersonService proxy = JAXRSClientFactory.create(webAppAddress, PersonService.class);
new PersonServiceProxyClient(proxy).useService();
} | java |
public static String readCorrelationId(Message message) {
if (!(message instanceof SoapMessage)) {
return null;
}
String correlationId = null;
Header hdCorrelationId = ((SoapMessage) message).getHeader(CORRELATION_ID_QNAME);
if (hdCorrelationId != null) {
if (hdCorrelationId.getObject() instanceof String) {
correlationId = (String) hdCorrelationId.getObject();
} else if (hdCorrelationId.getObject() instanceof Node) {
Node headerNode = (Node) hdCorrelationId.getObject();
correlationId = headerNode.getTextContent();
} else {
LOG.warning("Found CorrelationId soap header but value is not a String or a Node! Value: "
+ hdCorrelationId.getObject().toString());
}
}
return correlationId;
} | java |
public static void writeCorrelationId(Message message, String correlationId) {
if (!(message instanceof SoapMessage)) {
return;
}
SoapMessage soapMessage = (SoapMessage) message;
Header hdCorrelationId = soapMessage.getHeader(CORRELATION_ID_QNAME);
if (hdCorrelationId != null) {
LOG.warning("CorrelationId already existing in soap header, need not to write CorrelationId header.");
return;
}
if ((soapMessage.getContent(javax.xml.stream.XMLStreamWriter.class) != null)
&& (soapMessage.getContent(javax.xml.stream.XMLStreamWriter.class) instanceof SAAJStreamWriter)
&& (((SAAJStreamWriter) soapMessage.getContent(javax.xml.stream.XMLStreamWriter.class))
.getDocument()
.getElementsByTagNameNS("http://www.talend.com/esb/sam/correlationId/v1",
"correlationId").getLength() > 0)) {
LOG.warning("CorrelationId already existing in soap header, need not to write CorrelationId header.");
return;
}
try {
soapMessage.getHeaders().add(
new Header(CORRELATION_ID_QNAME, correlationId, new JAXBDataBinding(String.class)));
if (LOG.isLoggable(Level.FINE)) {
LOG.fine("Stored correlationId '" + correlationId + "' in soap header: "
+ CORRELATION_ID_QNAME);
}
} catch (JAXBException e) {
LOG.log(Level.SEVERE, "Couldn't create correlationId header.", e);
}
} | java |
public void handleEvent(Event event) {
LOG.fine("ContentLengthHandler called");
//if maximum length is shorter then <cut><![CDATA[ ]]></cut> it's not possible to cut the content
if(CUT_START_TAG.length() + CUT_END_TAG.length() > length) {
LOG.warning("Trying to cut content. But length is shorter then needed for "
+ CUT_START_TAG + CUT_END_TAG + ". So content is skipped.");
event.setContent("");
return;
}
int currentLength = length - CUT_START_TAG.length() - CUT_END_TAG.length();
if (event.getContent() != null && event.getContent().length() > length) {
LOG.fine("cutting content to " + currentLength
+ " characters. Original length was "
+ event.getContent().length());
LOG.fine("Content before cutting: " + event.getContent());
event.setContent(CUT_START_TAG
+ event.getContent().substring(0, currentLength) + CUT_END_TAG);
LOG.fine("Content after cutting: " + event.getContent());
}
} | java |
public static XMLGregorianCalendar convertDate(Date date) {
if (date == null) {
return null;
}
GregorianCalendar gc = new GregorianCalendar();
gc.setTimeInMillis(date.getTime());
try {
return getDatatypeFactory().newXMLGregorianCalendar(gc);
} catch (DatatypeConfigurationException ex) {
return null;
}
} | java |
public static CustomInfo getOrCreateCustomInfo(Message message) {
CustomInfo customInfo = message.get(CustomInfo.class);
if (customInfo == null) {
customInfo = new CustomInfo();
message.put(CustomInfo.class, customInfo);
}
return customInfo;
} | java |
public static boolean isMessageContentToBeLogged(final Message message, final boolean logMessageContent,
boolean logMessageContentOverride) {
/*
* If controlling of logging behavior is not allowed externally
* then log according to global property value
*/
if (!logMessageContentOverride) {
return logMessageContent;
}
Object logMessageContentExtObj = message.getContextualProperty(EXTERNAL_PROPERTY_NAME);
if (null == logMessageContentExtObj) {
return logMessageContent;
} else if (logMessageContentExtObj instanceof Boolean) {
return ((Boolean) logMessageContentExtObj).booleanValue();
} else if (logMessageContentExtObj instanceof String) {
String logMessageContentExtVal = (String) logMessageContentExtObj;
if (logMessageContentExtVal.equalsIgnoreCase("true")) {
return true;
} else if (logMessageContentExtVal.equalsIgnoreCase("false")) {
return false;
} else {
return logMessageContent;
}
} else {
return logMessageContent;
}
} | java |
public void initLocator() throws InterruptedException,
ServiceLocatorException {
if (locatorClient == null) {
if (LOG.isLoggable(Level.FINE)) {
LOG.fine("Instantiate locatorClient client for Locator Server "
+ locatorEndpoints + "...");
}
ServiceLocatorImpl client = new ServiceLocatorImpl();
client.setLocatorEndpoints(locatorEndpoints);
client.setConnectionTimeout(connectionTimeout);
client.setSessionTimeout(sessionTimeout);
if (null != authenticationName)
client.setName(authenticationName);
if (null != authenticationPassword)
client.setPassword(authenticationPassword);
locatorClient = client;
locatorClient.connect();
}
} | java |
@PreDestroy
public void disconnectLocator() throws InterruptedException,
ServiceLocatorException {
if (LOG.isLoggable(Level.FINE)) {
LOG.fine("Destroy Locator client");
}
if (endpointCollector != null) {
endpointCollector.stopScheduledCollection();
}
if (locatorClient != null) {
locatorClient.disconnect();
locatorClient = null;
}
} | java |
List<W3CEndpointReference> lookupEndpoints(QName serviceName,
MatcherDataType matcherData) throws ServiceLocatorFault,
InterruptedExceptionFault {
SLPropertiesMatcher matcher = createMatcher(matcherData);
List<String> names = null;
List<W3CEndpointReference> result = new ArrayList<W3CEndpointReference>();
String adress;
try {
initLocator();
if (matcher == null) {
names = locatorClient.lookup(serviceName);
} else {
names = locatorClient.lookup(serviceName, matcher);
}
} catch (ServiceLocatorException e) {
ServiceLocatorFaultDetail serviceFaultDetail = new ServiceLocatorFaultDetail();
serviceFaultDetail.setLocatorFaultDetail(serviceName.toString()
+ "throws ServiceLocatorFault");
throw new ServiceLocatorFault(e.getMessage(), serviceFaultDetail);
} catch (InterruptedException e) {
InterruptionFaultDetail interruptionFaultDetail = new InterruptionFaultDetail();
interruptionFaultDetail.setInterruptionDetail(serviceName
.toString() + "throws InterruptionFault");
throw new InterruptedExceptionFault(e.getMessage(),
interruptionFaultDetail);
}
if (names != null && !names.isEmpty()) {
for (int i = 0; i < names.size(); i++) {
adress = names.get(i);
result.add(buildEndpoint(serviceName, adress));
}
} else {
if (LOG.isLoggable(Level.WARNING)) {
LOG.log(Level.WARNING, "lookup Endpoints for " + serviceName
+ " failed, service is not known.");
}
ServiceLocatorFaultDetail serviceFaultDetail = new ServiceLocatorFaultDetail();
serviceFaultDetail.setLocatorFaultDetail("lookup Endpoint for "
+ serviceName + " failed, service is not known.");
throw new ServiceLocatorFault("Can not find Endpoint",
serviceFaultDetail);
}
return result;
} | java |
private List<String> getRotatedList(List<String> strings) {
int index = RANDOM.nextInt(strings.size());
List<String> rotated = new ArrayList<String>();
for (int i = 0; i < strings.size(); i++) {
rotated.add(strings.get(index));
index = (index + 1) % strings.size();
}
return rotated;
} | java |
@Override
public void start(String[] arguments) {
boolean notStarted = !started.getAndSet(true);
if (notStarted) {
start(new MultiInstanceWorkloadStrategy(factory, name, arguments, endpointRegistry, execService));
}
} | java |
protected void processStart(Endpoint endpoint, EventTypeEnum eventType) {
if (!sendLifecycleEvent) {
return;
}
Event event = createEvent(endpoint, eventType);
queue.add(event);
} | java |
protected void processStop(Endpoint endpoint, EventTypeEnum eventType) {
if (!sendLifecycleEvent) {
return;
}
Event event = createEvent(endpoint, eventType);
monitoringServiceClient.putEvents(Collections.singletonList(event));
if (LOG.isLoggable(Level.INFO)) {
LOG.info("Send " + eventType + " event to SAM Server successful!");
}
} | java |
private Event createEvent(Endpoint endpoint, EventTypeEnum type) {
Event event = new Event();
MessageInfo messageInfo = new MessageInfo();
Originator originator = new Originator();
event.setMessageInfo(messageInfo);
event.setOriginator(originator);
Date date = new Date();
event.setTimestamp(date);
event.setEventType(type);
messageInfo.setPortType(
endpoint.getBinding().getBindingInfo().getService().getInterface().getName().toString());
String transportType = null;
if (endpoint.getBinding() instanceof SoapBinding) {
SoapBinding soapBinding = (SoapBinding)endpoint.getBinding();
if (soapBinding.getBindingInfo() instanceof SoapBindingInfo) {
SoapBindingInfo soapBindingInfo = (SoapBindingInfo)soapBinding.getBindingInfo();
transportType = soapBindingInfo.getTransportURI();
}
}
messageInfo.setTransportType((transportType != null) ? transportType : "Unknown transport type");
originator.setProcessId(Converter.getPID());
try {
InetAddress inetAddress = InetAddress.getLocalHost();
originator.setIp(inetAddress.getHostAddress());
originator.setHostname(inetAddress.getHostName());
} catch (UnknownHostException e) {
originator.setHostname("Unknown hostname");
originator.setIp("Unknown ip address");
}
String address = endpoint.getEndpointInfo().getAddress();
event.getCustomInfo().put("address", address);
return event;
} | java |
public void useOldRESTService() throws Exception {
List<Object> providers = createJAXRSProviders();
com.example.customerservice.CustomerService customerService = JAXRSClientFactory
.createFromModel("http://localhost:" + port + "/examples/direct/rest",
com.example.customerservice.CustomerService.class,
"classpath:/model/CustomerService-jaxrs.xml",
providers,
null);
System.out.println("Using old RESTful CustomerService with old client");
customer.v1.Customer customer = createOldCustomer("Smith Old REST");
customerService.updateCustomer(customer);
customer = customerService.getCustomerByName("Smith Old REST");
printOldCustomerDetails(customer);
} | java |
public void useNewRESTService(String address) throws Exception {
List<Object> providers = createJAXRSProviders();
org.customer.service.CustomerService customerService = JAXRSClientFactory
.createFromModel(address,
org.customer.service.CustomerService.class,
"classpath:/model/CustomerService-jaxrs.xml",
providers,
null);
System.out.println("Using new RESTful CustomerService with new client");
customer.v2.Customer customer = createNewCustomer("Smith New REST");
customerService.updateCustomer(customer);
customer = customerService.getCustomerByName("Smith New REST");
printNewCustomerDetails(customer);
} | java |
public void useNewRESTServiceWithOldClient() throws Exception {
List<Object> providers = createJAXRSProviders();
com.example.customerservice.CustomerService customerService = JAXRSClientFactory
.createFromModel("http://localhost:" + port + "/examples/direct/new-rest",
com.example.customerservice.CustomerService.class,
"classpath:/model/CustomerService-jaxrs.xml",
providers,
null);
// The outgoing old Customer data needs to be transformed for
// the new service to understand it and the response from the new service
// needs to be transformed for this old client to understand it.
ClientConfiguration config = WebClient.getConfig(customerService);
addTransformInterceptors(config.getInInterceptors(),
config.getOutInterceptors(),
false);
System.out.println("Using new RESTful CustomerService with old Client");
customer.v1.Customer customer = createOldCustomer("Smith Old to New REST");
customerService.updateCustomer(customer);
customer = customerService.getCustomerByName("Smith Old to New REST");
printOldCustomerDetails(customer);
} | java |
@PostConstruct
public void init() {
//init Bus and LifeCycle listeners
if (bus != null && sendLifecycleEvent ) {
ServerLifeCycleManager slcm = bus.getExtension(ServerLifeCycleManager.class);
if (null != slcm) {
ServiceListenerImpl svrListener = new ServiceListenerImpl();
svrListener.setSendLifecycleEvent(sendLifecycleEvent);
svrListener.setQueue(queue);
svrListener.setMonitoringServiceClient(monitoringServiceClient);
slcm.registerListener(svrListener);
}
ClientLifeCycleManager clcm = bus.getExtension(ClientLifeCycleManager.class);
if (null != clcm) {
ClientListenerImpl cltListener = new ClientListenerImpl();
cltListener.setSendLifecycleEvent(sendLifecycleEvent);
cltListener.setQueue(queue);
cltListener.setMonitoringServiceClient(monitoringServiceClient);
clcm.registerListener(cltListener);
}
}
if(executorQueueSize == 0) {
executor = Executors.newFixedThreadPool(this.executorPoolSize);
}else{
executor = new ThreadPoolExecutor(executorPoolSize, executorPoolSize, 0, TimeUnit.SECONDS,
new LinkedBlockingQueue<Runnable>(executorQueueSize), Executors.defaultThreadFactory(),
new RejectedExecutionHandlerImpl());
}
scheduler = new Timer();
scheduler.scheduleAtFixedRate(new TimerTask() {
public void run() {
sendEventsFromQueue();
}
}, 0, getDefaultInterval());
} | java |
public void setDefaultInterval(long defaultInterval) {
if(defaultInterval <= 0) {
LOG.severe("collector.scheduler.interval must be greater than 0. Recommended value is 500-1000. Current value is " + defaultInterval);
throw new IllegalArgumentException("collector.scheduler.interval must be greater than 0. Recommended value is 500-1000. Current value is " + defaultInterval);
}
this.defaultInterval = defaultInterval;
} | java |
public void sendEventsFromQueue() {
if (null == queue || stopSending) {
return;
}
LOG.fine("Scheduler called for sending events");
int packageSize = getEventsPerMessageCall();
while (!queue.isEmpty()) {
final List<Event> list = new ArrayList<Event>();
int i = 0;
while (i < packageSize && !queue.isEmpty()) {
Event event = queue.remove();
if (event != null && !filter(event)) {
list.add(event);
i++;
}
}
if (list.size() > 0) {
executor.execute(new Runnable() {
public void run() {
try {
sendEvents(list);
} catch (MonitoringException e) {
e.logException(Level.SEVERE);
}
}
});
}
}
} | java |
private void sendEvents(final List<Event> events) {
if (null != handlers) {
for (EventHandler current : handlers) {
for (Event event : events) {
current.handleEvent(event);
}
}
}
LOG.info("Put events(" + events.size() + ") to Monitoring Server.");
try {
if (sendToEventadmin) {
EventAdminPublisher.publish(events);
} else {
monitoringServiceClient.putEvents(events);
}
} catch (MonitoringException e) {
throw e;
} catch (Exception e) {
throw new MonitoringException("002",
"Unknown error while execute put events to Monitoring Server", e);
}
} | java |
@Override
public void start(String[] arguments) {
boolean notStarted = !started.getAndSet(true);
if (notStarted) {
start(new SingleInstanceWorkloadStrategy(job, name, arguments, endpointRegistry, execService));
}
} | java |
public static void writeCorrelationId(Message message, String correlationId) {
Map<String, List<String>> headers = getOrCreateProtocolHeader(message);
headers.put(CORRELATIONID_HTTP_HEADER_NAME, Collections.singletonList(correlationId));
if (LOG.isLoggable(Level.FINE)) {
LOG.fine("HTTP header '" + CORRELATIONID_HTTP_HEADER_NAME + "' set to: " + correlationId);
}
} | java |
public static String readFlowId(Message message) {
String flowId = null;
Map<String, List<String>> headers = getOrCreateProtocolHeader(message);
List<String> flowIds = headers.get(FLOWID_HTTP_HEADER_NAME);
if (flowIds != null && flowIds.size() > 0) {
flowId = flowIds.get(0);
if (LOG.isLoggable(Level.FINE)) {
LOG.fine("HTTP header '" + FLOWID_HTTP_HEADER_NAME + "' found: " + flowId);
}
} else {
if (LOG.isLoggable(Level.FINE)) {
LOG.fine("No HTTP header '" + FLOWID_HTTP_HEADER_NAME + "' found");
}
}
return flowId;
} | java |
public static void writeFlowId(Message message, String flowId) {
Map<String, List<String>> headers = getOrCreateProtocolHeader(message);
headers.put(FLOWID_HTTP_HEADER_NAME, Collections.singletonList(flowId));
if (LOG.isLoggable(Level.FINE)) {
LOG.fine("HTTP header '" + FLOWID_HTTP_HEADER_NAME + "' set to: " + flowId);
}
} | java |
public static void addInterceptors(InterceptorProvider provider) {
PhaseManager phases = BusFactory.getDefaultBus().getExtension(PhaseManager.class);
for (Phase p : phases.getInPhases()) {
provider.getInInterceptors().add(new DemoInterceptor(p.getName()));
provider.getInFaultInterceptors().add(new DemoInterceptor(p.getName()));
}
for (Phase p : phases.getOutPhases()) {
provider.getOutInterceptors().add(new DemoInterceptor(p.getName()));
provider.getOutFaultInterceptors().add(new DemoInterceptor(p.getName()));
}
} | java |
private boolean somethingMayHaveChanged(PhaseInterceptorChain pic) {
Iterator<Interceptor<? extends Message>> it = pic.iterator();
Interceptor<? extends Message> last = null;
while (it.hasNext()) {
Interceptor<? extends Message> cur = it.next();
if (cur == this) {
if (last instanceof DemoInterceptor) {
return false;
}
return true;
}
last = cur;
}
return true;
} | java |
public void printInterceptorChain(InterceptorChain chain) {
Iterator<Interceptor<? extends Message>> it = chain.iterator();
String phase = "";
StringBuilder builder = null;
while (it.hasNext()) {
Interceptor<? extends Message> interceptor = it.next();
if (interceptor instanceof DemoInterceptor) {
continue;
}
if (interceptor instanceof PhaseInterceptor) {
PhaseInterceptor pi = (PhaseInterceptor)interceptor;
if (!phase.equals(pi.getPhase())) {
if (builder != null) {
System.out.println(builder.toString());
} else {
builder = new StringBuilder(100);
}
builder.setLength(0);
builder.append(" ");
builder.append(pi.getPhase());
builder.append(": ");
phase = pi.getPhase();
}
String id = pi.getId();
int idx = id.lastIndexOf('.');
if (idx != -1) {
id = id.substring(idx + 1);
}
builder.append(id);
builder.append(' ');
}
}
} | java |
public com.squareup.okhttp.Call getCharactersCharacterIdShipCall(Integer characterId, String datasource,
String ifNoneMatch, String token, final ApiCallback callback) throws ApiException {
Object localVarPostBody = new Object();
// create path and map variables
String localVarPath = "/v1/characters/{character_id}/ship/".replaceAll("\\{" + "character_id" + "\\}",
apiClient.escapeString(characterId.toString()));
List<Pair> localVarQueryParams = new ArrayList<Pair>();
List<Pair> localVarCollectionQueryParams = new ArrayList<Pair>();
if (datasource != null) {
localVarQueryParams.addAll(apiClient.parameterToPair("datasource", datasource));
}
if (token != null) {
localVarQueryParams.addAll(apiClient.parameterToPair("token", token));
}
Map<String, String> localVarHeaderParams = new HashMap<String, String>();
if (ifNoneMatch != null) {
localVarHeaderParams.put("If-None-Match", apiClient.parameterToString(ifNoneMatch));
}
Map<String, Object> localVarFormParams = new HashMap<String, Object>();
final String[] localVarAccepts = { "application/json" };
final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);
if (localVarAccept != null) {
localVarHeaderParams.put("Accept", localVarAccept);
}
final String[] localVarContentTypes = {
};
final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);
localVarHeaderParams.put("Content-Type", localVarContentType);
String[] localVarAuthNames = new String[] { "evesso" };
return apiClient.buildCall(localVarPath, "GET", localVarQueryParams, localVarCollectionQueryParams,
localVarPostBody, localVarHeaderParams, localVarFormParams, localVarAuthNames, callback);
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.