/**
* Place to put some hacks if needed on incoming requests.
*
* @param event the incoming request event.
* @return status <code>true</code> if we don't need to process this message, just discard it and
* <code>false</code> otherwise.
*/
private boolean applyNonConformanceHacks(RequestEvent event) {
Request request = event.getRequest();
try {
/*
* Max-Forwards is required, yet there are UAs which do not
* place it. SipProvider#getNewServerTransaction(Request)
* will throw an exception in the case of a missing
* Max-Forwards header and this method will eventually just
* log it thus ignoring the whole event.
*/
if (request.getHeader(MaxForwardsHeader.NAME) == null) {
// it appears that some buggy providers do send requests
// with no Max-Forwards headers, as we are at application level
// and we know there will be no endless loops
// there is no problem of adding headers and process normally
// this messages
MaxForwardsHeader maxForwards =
SipFactory.getInstance().createHeaderFactory().createMaxForwardsHeader(70);
request.setHeader(maxForwards);
}
} catch (Throwable ex) {
logger.warn("Cannot apply incoming request modification!", ex);
}
try {
// using asterisk voice mail initial notify for messages
// is ok, but on the fly received messages their notify comes
// without subscription-state, so we add it in order to be able to
// process message.
if (request.getMethod().equals(Request.NOTIFY)
&& request.getHeader(EventHeader.NAME) != null
&& ((EventHeader) request.getHeader(EventHeader.NAME))
.getEventType()
.equals(OperationSetMessageWaitingSipImpl.EVENT_PACKAGE)
&& request.getHeader(SubscriptionStateHeader.NAME) == null) {
request.addHeader(
new HeaderFactoryImpl().createSubscriptionStateHeader(SubscriptionStateHeader.ACTIVE));
}
} catch (Throwable ex) {
logger.warn("Cannot apply incoming request modification!", ex);
}
try {
// receiving notify message without subscription state
// used for keep-alive pings, they have done their job
// and are no more need. Skip processing them to avoid
// filling logs with unneeded exceptions.
if (request.getMethod().equals(Request.NOTIFY)
&& request.getHeader(SubscriptionStateHeader.NAME) == null) {
return true;
}
} catch (Throwable ex) {
logger.warn("Cannot apply incoming request modification!", ex);
}
return false;
}
/**
* Downloads a Bundle file for a given bundle id.
*
* @param request HttpRequest
* @param response HttpResponse
* @throws IOException If fails sending back to the user response information
*/
public void downloadBundle(HttpServletRequest request, HttpServletResponse response)
throws IOException {
try {
if (!APILocator.getLayoutAPI()
.doesUserHaveAccessToPortlet("EXT_CONTENT_PUBLISHING_TOOL", getUser())) {
response.sendError(401);
return;
}
} catch (DotDataException e1) {
Logger.error(RemotePublishAjaxAction.class, e1.getMessage(), e1);
response.sendError(401);
return;
}
Map<String, String> map = getURIParams();
response.setContentType("application/x-tgz");
String bid = map.get("bid");
PublisherConfig config = new PublisherConfig();
config.setId(bid);
File bundleRoot = BundlerUtil.getBundleRoot(config);
ArrayList<File> list = new ArrayList<File>(1);
list.add(bundleRoot);
File bundle =
new File(bundleRoot + File.separator + ".." + File.separator + config.getId() + ".tar.gz");
if (!bundle.exists()) {
response.sendError(500, "No Bundle Found");
return;
}
response.setHeader("Content-Disposition", "attachment; filename=" + config.getId() + ".tar.gz");
BufferedInputStream in = null;
try {
in = new BufferedInputStream(new FileInputStream(bundle));
byte[] buf = new byte[4096];
int len;
while ((len = in.read(buf, 0, buf.length)) != -1) {
response.getOutputStream().write(buf, 0, len);
}
} catch (Exception e) {
Logger.warn(this.getClass(), "Error Downloading Bundle.", e);
} finally {
try {
in.close();
} catch (Exception ex) {
Logger.warn(this.getClass(), "Error Closing Stream.", ex);
}
}
return;
}
/**
* Restarts the recording for a specific SSRC.
*
* @param ssrc the SSRC for which to restart recording. RTP packet of the new recording).
*/
private void resetRecording(long ssrc, long timestamp) {
ReceiveStreamDesc receiveStream = findReceiveStream(ssrc);
// we only restart audio recordings
if (receiveStream != null && receiveStream.format instanceof AudioFormat) {
String newFilename = getNextFilename(path + "/" + ssrc, AUDIO_FILENAME_SUFFIX);
// flush the buffer contained in the MP3 encoder
String s = "trying to flush ssrc=" + ssrc;
Processor p = receiveStream.processor;
if (p != null) {
s += " p!=null";
for (TrackControl tc : p.getTrackControls()) {
Object o = tc.getControl(FlushableControl.class.getName());
if (o != null) ((FlushableControl) o).flush();
}
}
if (logger.isInfoEnabled()) {
logger.info("Restarting recording for SSRC=" + ssrc + ". New filename: " + newFilename);
}
receiveStream.dataSink.close();
receiveStream.dataSink = null;
// flush the FMJ jitter buffer
// DataSource ds = receiveStream.receiveStream.getDataSource();
// if (ds instanceof net.sf.fmj.media.protocol.rtp.DataSource)
// ((net.sf.fmj.media.protocol.rtp.DataSource)ds).flush();
receiveStream.filename = newFilename;
try {
receiveStream.dataSink =
Manager.createDataSink(
receiveStream.dataSource, new MediaLocator("file:" + newFilename));
} catch (NoDataSinkException ndse) {
logger.warn("Could not reset recording for SSRC=" + ssrc + ": " + ndse);
removeReceiveStream(receiveStream, false);
}
try {
receiveStream.dataSink.open();
receiveStream.dataSink.start();
} catch (IOException ioe) {
logger.warn("Could not reset recording for SSRC=" + ssrc + ": " + ioe);
removeReceiveStream(receiveStream, false);
}
audioRecordingStarted(ssrc, timestamp);
}
}
/**
* Receives options requests and replies with an OK response containing methods that we support.
*
* @param requestEvent the incoming options request.
* @return <tt>true</tt> if request has been successfully processed, <tt>false</tt> otherwise
*/
@Override
public boolean processRequest(RequestEvent requestEvent) {
Response optionsOK = null;
try {
optionsOK =
provider.getMessageFactory().createResponse(Response.OK, requestEvent.getRequest());
// add to the allows header all methods that we support
for (String method : provider.getSupportedMethods()) {
// don't support REGISTERs
if (!method.equals(Request.REGISTER))
optionsOK.addHeader(provider.getHeaderFactory().createAllowHeader(method));
}
Iterable<String> knownEventsList = provider.getKnownEventsList();
synchronized (knownEventsList) {
for (String event : knownEventsList)
optionsOK.addHeader(provider.getHeaderFactory().createAllowEventsHeader(event));
}
} catch (ParseException ex) {
// What else could we do apart from logging?
logger.warn("Failed to create an incoming OPTIONS request", ex);
return false;
}
try {
SipStackSharing.getOrCreateServerTransaction(requestEvent).sendResponse(optionsOK);
} catch (TransactionUnavailableException ex) {
// this means that we received an OPTIONS request outside the scope
// of a transaction which could mean that someone is simply sending
// us b****hit to keep a NAT connection alive, so let's not get too
// excited.
if (logger.isInfoEnabled())
logger.info("Failed to respond to an incoming " + "transactionless OPTIONS request");
if (logger.isTraceEnabled()) logger.trace("Exception was:", ex);
return false;
} catch (InvalidArgumentException ex) {
// What else could we do apart from logging?
logger.warn("Failed to send an incoming OPTIONS request", ex);
return false;
} catch (SipException ex) {
// What else could we do apart from logging?
logger.warn("Failed to send an incoming OPTIONS request", ex);
return false;
}
return true;
}
private void removeReceiveStream(ReceiveStreamDesc receiveStream, boolean emptyJB) {
if (receiveStream.format instanceof VideoFormat) {
rtpConnector.packetBuffer.disable(receiveStream.ssrc);
emptyPacketBuffer(receiveStream.ssrc);
}
if (receiveStream.dataSink != null) {
try {
receiveStream.dataSink.stop();
} catch (IOException e) {
logger.error("Failed to stop DataSink " + e);
}
receiveStream.dataSink.close();
}
if (receiveStream.processor != null) {
receiveStream.processor.stop();
receiveStream.processor.close();
}
DataSource dataSource = receiveStream.receiveStream.getDataSource();
if (dataSource != null) {
try {
dataSource.stop();
} catch (IOException ioe) {
logger.warn("Failed to stop DataSource");
}
dataSource.disconnect();
}
synchronized (receiveStreams) {
receiveStreams.remove(receiveStream);
}
}
protected List<MappingWithDirection> findApplicable(MappingKey key) {
ArrayList<MappingWithDirection> result = new ArrayList<MappingWithDirection>();
for (ParsedMapping pm : mappings) {
if ((pm.mappingCase == null && key.mappingCase == null)
^ (pm.mappingCase != null && pm.mappingCase.equals(key.mappingCase))) {
if (pm.sideA.isAssignableFrom(key.source) && pm.sideB.isAssignableFrom(key.target))
result.add(new MappingWithDirection(pm, true));
else if (pm.sideB.isAssignableFrom(key.source) && pm.sideA.isAssignableFrom(key.target))
result.add(new MappingWithDirection(pm, false));
}
}
if (!result.isEmpty()) {
Collections.sort(result, new MappingComparator(key.target));
} else if (automappingEnabled) {
logger.info(
"Could not find applicable mappings between {} and {}. A mapping will be created using automapping facility",
key.source.getName(),
key.target.getName());
ParsedMapping pm = new Mapping(key.source, key.target, this).automap().parse();
logger.debug("Automatically created {}", pm);
mappings.add(pm);
result.add(new MappingWithDirection(pm, true));
} else
logger.warn(
"Could not find applicable mappings between {} and {}!",
key.source.getName(),
key.target.getName());
return result;
}
/**
* 返回响应结果
*
* @param response
* @return
*/
public static RestResponse returnResponse(
BaseRestRequest request,
RestResponse response,
RestServiceMapping serviceMapping,
RestServiceConfiguration configuration) {
String cmd = request.getRestRequest().getCmd();
// 调用后置拦截器
List<RestRequestAfterInterceptor> requestAfterInterceptors =
configuration.getRequestAfterInterceptors();
for (RestRequestAfterInterceptor requestInterceptor : requestAfterInterceptors) {
String requestInterceptorName = requestInterceptor.getName();
logger.debug(
"REST_AFTER_INTERCEPTOR_START, cmd: {}, name: {}",
cmd,
requestInterceptorName + "|" + requestInterceptor.getClass().getName());
try {
requestInterceptor.setConfiguration(configuration);
requestInterceptor.execute(serviceMapping, request, response);
} catch (Exception e) {
response.setException(e);
logger.warn("执行拦截器 {} 失败", requestInterceptorName, e);
}
logger.debug(
"REST_AFTER_INTERCEPTOR_COMPLETE， cmd: {}, name: {}",
cmd,
requestInterceptorName + "|" + requestInterceptor.getClass().getName());
}
return response;
}
/**
* Returns the <tt>URL</tt> of the sound corresponding to the given property key.
*
* @return the <tt>URL</tt> of the sound corresponding to the given property key.
*/
public URL getSoundURL(String urlKey) {
String path = getSoundPath(urlKey);
if (path == null || path.length() == 0) {
logger.warn("Missing resource for key: " + urlKey);
return null;
}
return getSoundURLForPath(path);
}
/**
* Returns the <tt>InputStream</tt> of the image corresponding to the given key.
*
* @param streamKey The identifier of the image in the resource properties file.
* @return the <tt>InputStream</tt> of the image corresponding to the given key.
*/
public InputStream getImageInputStream(String streamKey) {
String path = getImagePath(streamKey);
if (path == null || path.length() == 0) {
logger.warn("Missing resource for key: " + streamKey);
return null;
}
return getImageInputStreamForPath(path);
}
public ClientThread(Socket socket, History history, Users users) throws IOException {
logger.warn("New client is trying to connect to the chat...");
logger.info("Assigning a socket to a new client...");
this.s = socket;
logger.info("Getting the input stream...");
in = new DataInputStream(s.getInputStream());
logger.info("Getting the output stream...");
out = new DataOutputStream(s.getOutputStream());
this.users = users;
users.addObserver(this);
this.history = history;
start();
logger.warn("Connection with new user is established.");
}
/**
* Sets the priority of the calling thread to a specific value.
*
* @param threadPriority the priority to be set on the calling thread
*/
public static void setThreadPriority(int threadPriority) {
Throwable exception = null;
try {
Process.setThreadPriority(threadPriority);
} catch (IllegalArgumentException iae) {
exception = iae;
} catch (SecurityException se) {
exception = se;
}
if (exception != null) logger.warn("Failed to set thread priority.", exception);
}
protected void addOrReplace(ParsedMapping parsedMapping) {
MappingKey key = new MappingKey(parsedMapping);
for (int i = 0; i < mappings.size(); i++) {
if (key.equals(new MappingKey(mappings.get(i)))) {
logger.warn("{}\nis replaced with\n{}", mappings.get(i), parsedMapping);
mappings.set(i, parsedMapping);
return;
}
}
logger.debug("Parsed {}", parsedMapping);
mappings.add(parsedMapping);
}
/**
* Start desktop capture stream.
*
* @see AbstractPullBufferStream#start()
*/
@Override
public void start() throws IOException {
super.start();
if (desktopInteract == null) {
try {
desktopInteract = new DesktopInteractImpl();
} catch (Exception e) {
logger.warn("Cannot create DesktopInteract object!");
}
}
}
protected static void recordToErrorCounter(String cmd) {
String today = DateUtil.format(new Date(), "yyyyMMdd");
try {
RedisUtil.incr(ERROR_COUNT_KEY + today);
} catch (Exception e) {
logger.warn("记录api返回错误请求的次数失败, today: {}", today, e);
}
try {
RedisUtil.incr(ERROR_COUNT_KEY + today + ":cmd:" + cmd);
} catch (Exception e) {
logger.warn("记录cmd: {}, today: {} 返回错误请求的次数失败", cmd, today, e);
}
}
public void run() {
try {
prepareClient();
logger.info("Starting normal session with " + getClientName());
while (true) {
this.receive();
}
} catch (IOException ioe) {
logger.warn("Client " + this + " has been disconnected.");
this.setDisabled(true);
users.remove(this);
} finally {
try {
if (s != null && !s.isClosed()) {
s.close();
logger.warn("Socket with " + this + " has been closed.");
}
} catch (IOException ioe) {
logger.error("Socket has not been closed.", ioe);
}
}
}
/**
* Retrieves default values from xml.
*
* @param list the configuration list
*/
private static void parseDefaults(NodeList list) {
for (int i = 0; i < list.getLength(); ++i) {
NamedNodeMap mapping = list.item(i).getAttributes();
String attribute = mapping.getNamedItem("attribute").getNodeValue();
String value = mapping.getNamedItem("value").getNodeValue();
try {
Default field = Default.fromString(attribute);
DEFAULTS.put(field, value);
} catch (IllegalArgumentException exc) {
logger.warn("Unrecognized default attribute: " + attribute);
}
}
}
/**
* Populates LOCALES list with contents of xml.
*
* @param list the configuration list
*/
private static void parseLocales(NodeList list) {
for (int i = 0; i < list.getLength(); ++i) {
Node node = list.item(i);
NamedNodeMap attributes = node.getAttributes();
String label = ((Attr) attributes.getNamedItem("label")).getValue();
String code = ((Attr) attributes.getNamedItem("isoCode")).getValue();
String dictLocation = ((Attr) attributes.getNamedItem("dictionaryUrl")).getValue();
try {
LOCALES.add(new Locale(label, code, new URL(dictLocation)));
} catch (MalformedURLException exc) {
logger.warn(
"Unable to parse dictionary location of " + label + " (" + dictLocation + ")", exc);
}
}
}
private static void processFile(
String pid, File child, File outFilePath, String guidelineId, String htmlFilePath) {
// Write to output directory
// outFilePath should be path+pid+extension
String caseData = null;
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
java.util.Date startTime = new java.util.Date();
try {
caseData = readFileAsString(child.getPath());
} catch (java.io.IOException e) {
logger.error("Error reading data file ", e);
System.exit(-1);
}
String recommendations = null;
try {
System.out.println("-----------------------------------------");
recommendations =
pca.topLevelComputeAdvisory(pid, caseData, formatter.format(startTime), guidelineId, pid);
System.out.println("-----------------------------------------");
// String fileName = outFilePath+pid+fileExtension
// File outFilePath = new File(fileName);;
logger.warn("Output recommenations to: " + outFilePath);
if (outFilePath.exists()) {
outFilePath.delete();
}
try {
PrintWriter out = new PrintWriter(outFilePath.getPath());
out.print(recommendations);
out.flush();
// System.out.println("****READY FILE PROCESSING****");
// create Ready file
// String readyFileName;
// readyFileName = outFilePath.getPath();
// System.out.println("Ready File Name Is: " + readyFileName); //Remove
// File readyFile = new File(readyFileName.replace(".xml","_READY.txt"));
// try {
// readyFile.createNewFile();
// System.out.println("****SUCCESS****"+readyFile.getPath());
// } catch (java.io.IOException e0) {
// System.out.println("Error creating READY file");
// }
} catch (FileNotFoundException e) {
e.printStackTrace();
}
} catch (PCA_Session_Exception e1) {
e1.printStackTrace();
}
}
static {
try {
URL url = SpellCheckActivator.bundleContext.getBundle().getResource(RESOURCE_LOC);
InputStream stream = url.openStream();
if (stream == null) throw new IOException();
// strict parsing options
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setValidating(false);
factory.setIgnoringComments(true);
factory.setIgnoringElementContentWhitespace(true);
// parses configuration xml
/*-
* Warning: Felix is unable to import the com.sun.rowset.internal
* package, meaning this can't use the XmlErrorHandler. This causes
* a warning and a default handler to be attached. Otherwise this
* should have: builder.setErrorHandler(new XmlErrorHandler());
*/
DocumentBuilder builder = factory.newDocumentBuilder();
Document doc = builder.parse(stream);
// iterates over nodes, parsing contents
Node root = doc.getChildNodes().item(1);
NodeList categories = root.getChildNodes();
for (int i = 0; i < categories.getLength(); ++i) {
Node node = categories.item(i);
if (node.getNodeName().equals(NODE_DEFAULTS)) {
parseDefaults(node.getChildNodes());
} else if (node.getNodeName().equals(NODE_LOCALES)) {
parseLocales(node.getChildNodes());
} else {
logger.warn("Unrecognized category: " + node.getNodeName());
}
}
} catch (IOException exc) {
logger.error("Unable to load spell checker parameters", exc);
} catch (SAXException exc) {
logger.error("Unable to parse spell checker parameters", exc);
} catch (ParserConfigurationException exc) {
logger.error("Unable to parse spell checker parameters", exc);
}
}
/**
* Returns an InetAddress instance that represents the localhost, and that a socket can bind upon
* or distribute to peers as a contact address.
*
* @param intendedDestination the destination that we'd like to use the localhost address with.
* @return an InetAddress instance representing the local host, and that a socket can bind upon or
* distribute to peers as a contact address.
*/
public synchronized InetAddress getLocalHost(InetAddress intendedDestination) {
// no point in making sure that the localHostFinderSocket is initialized.
// better let it through a NullPointerException.
InetAddress localHost = null;
localHostFinderSocket.connect(intendedDestination, this.RANDOM_ADDR_DISC_PORT);
localHost = localHostFinderSocket.getLocalAddress();
localHostFinderSocket.disconnect();
// windows socket implementations return the any address so we need to
// find something else here ... InetAddress.getLocalHost seems to work
// better on windows so lets hope it'll do the trick.
if (localHost.isAnyLocalAddress()) {
try {
// all that's inside the if is an ugly IPv6 hack
// (good ol' IPv6 - always causing more problems than it solves.)
if (intendedDestination instanceof Inet6Address) {
// return the first globally routable ipv6 address we find
// on the machine (and hope it's a good one)
Enumeration interfaces = NetworkInterface.getNetworkInterfaces();
while (interfaces.hasMoreElements()) {
NetworkInterface iface = (NetworkInterface) interfaces.nextElement();
Enumeration addresses = iface.getInetAddresses();
while (addresses.hasMoreElements()) {
InetAddress address = (InetAddress) addresses.nextElement();
if (address instanceof Inet6Address) {
if (!address.isAnyLocalAddress()
&& !address.isLinkLocalAddress()
&& !address.isSiteLocalAddress()
&& !address.isLoopbackAddress()) {
return address;
}
}
}
}
} else localHost = InetAddress.getLocalHost();
/** @todo test on windows for ipv6 cases */
} catch (Exception ex) {
// sigh ... ok return 0.0.0.0
logger.warn("Failed to get localhost ", ex);
}
}
return localHost;
}
/**
* Function called when a icq file transfer request arrive
*
* @param manager the joustsim manager
* @param transfer the incoming transfer
*/
public void handleNewIncomingConnection(
RvConnectionManager manager, IncomingRvConnection transfer) {
if (transfer instanceof IncomingFileTransfer) {
if (logger.isTraceEnabled())
logger.trace("Incoming Icq file transfer request " + transfer.getClass());
if (!(transfer instanceof IncomingFileTransfer)) {
logger.warn("Wrong file transfer.");
return;
}
OperationSetPersistentPresenceIcqImpl opSetPersPresence =
(OperationSetPersistentPresenceIcqImpl)
icqProvider.getOperationSet(OperationSetPersistentPresence.class);
Contact sender =
opSetPersPresence.findContactByID(transfer.getBuddyScreenname().getFormatted());
IncomingFileTransfer incomingFileTransfer = (IncomingFileTransfer) transfer;
final Date newDate = new Date();
final IncomingFileTransferRequest req =
new IncomingFileTransferRequestIcqImpl(
icqProvider, this, incomingFileTransfer, sender, newDate);
// this handels when we receive request and before accept or decline
// it we receive cancel
transfer.addEventListener(
new RvConnectionEventListener() {
public void handleEventWithStateChange(
RvConnection transfer, RvConnectionState state, RvConnectionEvent event) {
if (state == FileTransferState.FAILED && event instanceof BuddyCancelledEvent) {
fireFileTransferRequestCanceled(
new FileTransferRequestEvent(
OperationSetFileTransferIcqImpl.this, req, newDate));
}
}
public void handleEvent(RvConnection arg0, RvConnectionEvent arg1) {}
});
fireFileTransferRequest(new FileTransferRequestEvent(this, req, newDate));
}
}
/**
* Builds a SgrScoreCalculator object
*
* @param data - name of file containing sgr data
* @param winSize - size of display window
* @throws IOException - if the file cannot be accessed
*/
public SgrScoreCalculator(String data, int winSize, CurationSet curation) throws IOException {
super(winSize);
BufferedReader br = new BufferedReader(new FileReader(data));
String line;
double minAbsScore = Double.POSITIVE_INFINITY;
Set<String> unmatchedIds = new HashSet<String>();
while ((line = br.readLine()) != null) {
String[] tokens = line.split("\t");
String refId = curation.getRefSequence().getName();
if (!tokens[0].equals(refId)) {
if (!unmatchedIds.contains(tokens[0])) {
logger.warn(
"Score id "
+ tokens[0]
+ " does not match main sequence id "
+ refId
+ ". Skipping score.");
unmatchedIds.add(tokens[0]);
}
continue;
}
Double score = new Double(Double.parseDouble(tokens[2]));
// chuck out scores outside of the given range
int pos = Integer.parseInt(tokens[1]);
if (pos >= curation.getLow() && pos <= curation.getHigh()) {
scoreMap.put(pos, score);
}
if (Math.abs(score) < minAbsScore) {
minAbsScore = Math.abs(score);
}
if (score.doubleValue() < minScore) {
minScore = score;
}
if (score.doubleValue() > maxScore) {
maxScore = score;
}
}
while (minAbsScore * factor < 1) {
factor *= 10;
}
}
/**
* Dispatches the event received from a JAIN-SIP <tt>SipProvider</tt> to one of our "candidate
* recipient" listeners.
*
* @param event the event received for a <tt>SipProvider</tt>.
*/
public void processResponse(ResponseEvent event) {
try {
// we don't have to accept the transaction since we
// created the request
ClientTransaction transaction = event.getClientTransaction();
if (logger.isTraceEnabled())
logger.trace(
"received response: "
+ event.getResponse().getStatusCode()
+ " "
+ event.getResponse().getReasonPhrase());
if (transaction == null) {
logger.warn("Transaction is null, probably already expired!");
return;
}
ProtocolProviderServiceSipImpl service = getServiceData(transaction);
if (service != null) {
// Mark the dialog for the dispatching of later in-dialog
// responses. If there is no dialog then the initial request
// sure is marked otherwise we won't have found the service with
// getServiceData(). The request has to be marked in case we
// receive one more response in an out-of-dialog transaction.
if (event.getDialog() != null) {
SipApplicationData.setApplicationData(
event.getDialog(), SipApplicationData.KEY_SERVICE, service);
}
service.processResponse(event);
} else {
logger.error(
"We received a response which "
+ "wasn't marked, please report this to "
+ "*****@*****.**");
}
} catch (Throwable exc) {
// any exception thrown within our code should be caught here
// so that we could log it rather than interrupt stack activity with
// it.
this.logApplicationException(DialogTerminatedEvent.class, exc);
}
}
/**
* {@inheritDoc}
*
* <p>SCTP input data callback.
*/
@Override
public void onSctpPacket(
byte[] data, int sid, int ssn, int tsn, long ppid, int context, int flags) {
if (ppid == WEB_RTC_PPID_CTRL) {
// Channel control PPID
try {
onCtrlPacket(data, sid);
} catch (IOException e) {
logger.error("IOException when processing ctrl packet", e);
}
} else if (ppid == WEB_RTC_PPID_STRING || ppid == WEB_RTC_PPID_BIN) {
WebRtcDataStream channel;
synchronized (this) {
channel = channels.get(sid);
}
if (channel == null) {
logger.error("No channel found for sid: " + sid);
return;
}
if (ppid == WEB_RTC_PPID_STRING) {
// WebRTC String
String str;
String charsetName = "UTF-8";
try {
str = new String(data, charsetName);
} catch (UnsupportedEncodingException uee) {
logger.error("Unsupported charset encoding/name " + charsetName, uee);
str = null;
}
channel.onStringMsg(str);
} else {
// WebRTC Binary
channel.onBinaryMsg(data);
}
} else {
logger.warn("Got message on unsupported PPID: " + ppid);
}
}
protected void generateView(Map<String, org.ektorp.support.DesignDocument.View> views, Field f) {
DocumentReferences referenceMetaData = f.getAnnotation(DocumentReferences.class);
if (referenceMetaData == null) {
LOG.warn("No DocumentReferences annotation found in field: ", f.getName());
return;
}
if (referenceMetaData.view().length() > 0) {
LOG.debug("Skipping view generation for field {} as view is already specified", f.getName());
return;
}
if (Set.class.isAssignableFrom(f.getType())) {
generateSetBasedDocRefView(views, f, referenceMetaData);
} else {
throw new ViewGenerationException(
String.format(
"The type of the field: %s in %s annotated with DocumentReferences is not supported. (Must be assignable from java.util.Set)",
f.getName(), f.getDeclaringClass()));
}
}
protected void generateView(
Map<String, org.ektorp.support.DesignDocument.View> views, Method me) {
DocumentReferences referenceMetaData = me.getAnnotation(DocumentReferences.class);
if (referenceMetaData == null) {
LOG.warn("No DocumentReferences annotation found in method: ", me.getName());
return;
}
if (!me.getName().startsWith("get")) {
throw new ViewGenerationException(
String.format(
"The method: %s in %s annotated with DocumentReferences does not conform to the naming convention of 'getXxxx'",
me.getName(), me.getDeclaringClass()));
}
if (Set.class.isAssignableFrom(me.getReturnType())) {
generateSetBasedDocRefView(views, me, referenceMetaData);
} else {
throw new ViewGenerationException(
String.format(
"The return type of: %s in %s annotated with DocumentReferences is not supported. (Must be assignable from java.util.Set)",
me.getName(), me.getDeclaringClass()));
}
}
/** Requests an HTTP resource and returns its response as a string */
public static String request(String httpUrl, Transaction tx) throws IOException {
checkTransaction(tx);
DataBuffer buffer = new DataBuffer(256, false);
InputStream is = null;
Connection conn = null;
try {
// append connection suffix
httpUrl += getConnectionSuffix();
Logger.log("Opening URL: " + httpUrl);
conn = Connector.open(httpUrl);
tx.setNetworkOperation(conn, is);
if (conn instanceof HttpConnection) {
HttpConnection httpConn = (HttpConnection) conn;
int responseCode = httpConn.getResponseCode();
is = httpConn.openInputStream();
tx.setNetworkOperation(conn, is);
int length = is.read(buffer.getArray());
buffer.setLength(length);
String response =
new String(buffer.getArray(), buffer.getArrayStart(), buffer.getArrayLength());
if (responseCode == 200) {
Logger.log("HTTP response: " + response);
return response;
} else {
Logger.warn("HTTP error response: " + response);
throw new IOException("Http error: " + responseCode + ", " + response);
}
} else {
throw new IOException("Can not make HTTP connection for URL '" + httpUrl + "'");
}
} finally {
PushUtils.close(conn, is, null);
tx.clearNetworkOperation();
}
}
public void loadStreams() throws Exception {
Config config = Config.getConfiguration("manager.streams");
afterLoadMap = new HashMap();
Object[] names = config.getArray("streams", null);
if (names == null) {
return;
}
for (int i = 0; i < names.length; i++) {
StreamDataSource sds = new StreamDataSource(names[i].toString());
sds.load();
sds.initiate();
addStreamNoFire(sds);
addDefault(sds);
}
Iterator it = afterLoadMap.keySet().iterator();
while (it.hasNext()) {
StreamDataSource sds = (StreamDataSource) it.next();
List sList = (List) afterLoadMap.get(sds);
Iterator addIt = sList.iterator();
while (addIt.hasNext()) {
Integer serial = (Integer) addIt.next();
StreamDataSource addStream = getStream(serial.intValue());
if (addStream != null) {
sds.addStream(addStream);
} else {
logger.warn("Unable to find source (" + serial + ") for " + sds);
}
}
}
afterLoadMap = null;
}
public void init() throws MQClientException {
nameServer = PropertyFileUtil.get("rocketmq.namesrv.domain");
if (StringUtils.isBlank(nameServer)) {
logger.warn("【MQ init】property rocketmq.namesrv.domain not found");
return;
}
if ("localTest".equals(nameServer)) {
logger.warn("【MQ init】localTest");
return;
}
if (StringUtils.isBlank(System.getProperty("rocketmq.namesrv.domain"))) {
System.setProperty("rocketmq.namesrv.domain", nameServer);
}
topicType = getTopic();
topic = RocketMqUtils.getTopic(topicType);
if (StringUtils.isBlank(group)) {
group = "S_" + topic.getTopic() + "_" + topic.getTags();
}
consumer = new DefaultMQPushConsumer(group);
consumer.setNamesrvAddr(nameServer);
consumer.setMessageModel(getMessageModel());
consumer.setConsumeThreadMin(minConsumeThread);
consumer.setConsumeThreadMax(maxConsumeThread);
// 可以不设置 设置后可以起多个 消费端
try {
consumer.setInstanceName("DEFAULT_CONSUMER-" + InetAddress.getLocalHost().getHostName());
} catch (UnknownHostException e) {
logger.error("getHostName error", e);
}
// 设置订阅的topic 设置订阅过滤表达式
if (StringUtils.isBlank(subExpression)) {
subExpression = topic.getTags();
consumer.subscribe(topic.getTopic(), subExpression);
} else {
consumer.subscribe(topic.getTopic(), subExpression);
}
try {
consumer.registerMessageListener(this);
consumer.start();
} catch (MQClientException e) {
logger.error(
"consumer start error!topic={},subExpression={},group={}",
topic.getTopic(),
subExpression,
group,
e);
}
logger.info(
"consumer start! topic={},subExpression={},group={}",
topic.getTopic(),
subExpression,
group);
}
/**
* Handles control packet.
*
* @param data raw packet data that arrived on control PPID.
* @param sid SCTP stream id on which the data has arrived.
*/
private synchronized void onCtrlPacket(byte[] data, int sid) throws IOException {
ByteBuffer buffer = ByteBuffer.wrap(data);
int messageType = /* 1 byte unsigned integer */ 0xFF & buffer.get();
if (messageType == MSG_CHANNEL_ACK) {
if (logger.isDebugEnabled()) {
logger.debug(getEndpoint().getID() + " ACK received SID: " + sid);
}
// Open channel ACK
WebRtcDataStream channel = channels.get(sid);
if (channel != null) {
// Ack check prevents from firing multiple notifications
// if we get more than one ACKs (by mistake/bug).
if (!channel.isAcknowledged()) {
channel.ackReceived();
notifyChannelOpened(channel);
} else {
logger.warn("Redundant ACK received for SID: " + sid);
}
} else {
logger.error("No channel exists on sid: " + sid);
}
} else if (messageType == MSG_OPEN_CHANNEL) {
int channelType = /* 1 byte unsigned integer */ 0xFF & buffer.get();
int priority = /* 2 bytes unsigned integer */ 0xFFFF & buffer.getShort();
long reliability = /* 4 bytes unsigned integer */ 0xFFFFFFFFL & buffer.getInt();
int labelLength = /* 2 bytes unsigned integer */ 0xFFFF & buffer.getShort();
int protocolLength = /* 2 bytes unsigned integer */ 0xFFFF & buffer.getShort();
String label;
String protocol;
if (labelLength == 0) {
label = "";
} else {
byte[] labelBytes = new byte[labelLength];
buffer.get(labelBytes);
label = new String(labelBytes, "UTF-8");
}
if (protocolLength == 0) {
protocol = "";
} else {
byte[] protocolBytes = new byte[protocolLength];
buffer.get(protocolBytes);
protocol = new String(protocolBytes, "UTF-8");
}
if (logger.isDebugEnabled()) {
logger.debug(
"!!! "
+ getEndpoint().getID()
+ " data channel open request on SID: "
+ sid
+ " type: "
+ channelType
+ " prio: "
+ priority
+ " reliab: "
+ reliability
+ " label: "
+ label
+ " proto: "
+ protocol);
}
if (channels.containsKey(sid)) {
logger.error("Channel on sid: " + sid + " already exists");
}
WebRtcDataStream newChannel = new WebRtcDataStream(sctpSocket, sid, label, true);
channels.put(sid, newChannel);
sendOpenChannelAck(sid);
notifyChannelOpened(newChannel);
} else {
logger.error("Unexpected ctrl msg type: " + messageType);
}
}