private Action batch() {
if (aggregate == null) {
aggregate = bufferPool.acquire(bufferSize, true);
if (LOG.isDebugEnabled()) {
LOG.debug("{} acquired aggregate buffer {}", FrameFlusher.this, aggregate);
}
}
// Do not allocate the iterator here.
for (int i = 0; i < entries.size(); ++i) {
FrameEntry entry = entries.get(i);
entry.generateHeaderBytes(aggregate);
ByteBuffer payload = entry.frame.getPayload();
if (BufferUtil.hasContent(payload)) {
BufferUtil.append(aggregate, payload);
}
}
if (LOG.isDebugEnabled()) {
LOG.debug("{} aggregated {} frames: {}", FrameFlusher.this, entries.size(), entries);
}
succeeded();
return Action.SCHEDULED;
}
/**
* Processes a new connection making it idle or active depending on whether requests are waiting
* to be sent.
*
* <p>A new connection is created when a request needs to be executed; it is possible that the
* request that triggered the request creation is executed by another connection that was just
* released, so the new connection may become idle.
*
* <p>If a request is waiting to be executed, it will be dequeued and executed by the new
* connection.
*
* @param connection the new connection
*/
public void process(final C connection) {
HttpClient client = getHttpClient();
final HttpExchange exchange = getHttpExchanges().poll();
if (LOG.isDebugEnabled())
LOG.debug("Processing exchange {} on {} of {}", exchange, connection, this);
if (exchange == null) {
if (!connectionPool.release(connection)) connection.close();
if (!client.isRunning()) {
if (LOG.isDebugEnabled()) LOG.debug("{} is stopping", client);
connection.close();
}
} else {
final Request request = exchange.getRequest();
Throwable cause = request.getAbortCause();
if (cause != null) {
if (LOG.isDebugEnabled()) LOG.debug("Aborted before processing {}: {}", exchange, cause);
// It may happen that the request is aborted before the exchange
// is created. Aborting the exchange a second time will result in
// a no-operation, so we just abort here to cover that edge case.
exchange.abort(cause);
} else {
send(connection, exchange);
}
}
}
@Override
public void run() {
if (LOG.isDebugEnabled()) {
LOG.debug("==> ConsumerRunnable.run()");
}
while (true) {
try {
if (hasNext()) {
EntityNotification notification = consumer.peek();
if (notification != null) {
if (LOG.isDebugEnabled()) {
LOG.debug("Notification=" + getPrintableEntityNotification(notification));
}
ServiceTags serviceTags =
AtlasNotificationMapper.processEntityNotification(notification);
if (serviceTags == null) {
LOG.error(
"No ServiceTags built for notification :"
+ getPrintableEntityNotification(notification));
} else {
updateSink(serviceTags);
}
} else {
LOG.error("Null entityNotification received from Kafka!! Ignoring..");
}
// Move iterator forward
consumer.next();
}
} catch (Exception exception) {
LOG.error("Caught exception..: ", exception);
return;
}
}
}
private void addLeafTask(TaskAttemptToSchedulerEvent event) {
TaskAttempt taskAttempt = event.getTaskAttempt();
List<DataLocation> locations = taskAttempt.getTask().getDataLocations();
for (DataLocation location : locations) {
String host = location.getHost();
leafTaskHosts.add(host);
HostVolumeMapping hostVolumeMapping = leafTaskHostMapping.get(host);
if (hostVolumeMapping == null) {
String rack = RackResolver.resolve(host).getNetworkLocation();
hostVolumeMapping = new HostVolumeMapping(host, rack);
leafTaskHostMapping.put(host, hostVolumeMapping);
}
hostVolumeMapping.addTaskAttempt(location.getVolumeId(), taskAttempt);
if (LOG.isDebugEnabled()) {
LOG.debug("Added attempt req to host " + host);
}
HashSet<TaskAttemptId> list = leafTasksRackMapping.get(hostVolumeMapping.getRack());
if (list == null) {
list = new HashSet<>();
leafTasksRackMapping.put(hostVolumeMapping.getRack(), list);
}
list.add(taskAttempt.getId());
if (LOG.isDebugEnabled()) {
LOG.debug("Added attempt req to rack " + hostVolumeMapping.getRack());
}
}
leafTasks.add(taskAttempt.getId());
}
public void run() {
if (LOG.isDebugEnabled()) {
LOG.debug("Cleaning up expired web clients.");
}
synchronized (ajaxWebClients) {
Iterator<Map.Entry<String, AjaxWebClient>> it = ajaxWebClients.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<String, AjaxWebClient> e = it.next();
String key = e.getKey();
AjaxWebClient val = e.getValue();
if (LOG.isDebugEnabled()) {
LOG.debug(
"AjaxWebClient "
+ key
+ " last accessed "
+ val.getMillisSinceLastAccessed() / 1000
+ " seconds ago.");
}
// close an expired client and remove it from the ajaxWebClients hash.
if (val.closeIfExpired()) {
if (LOG.isDebugEnabled()) {
LOG.debug("Removing expired AjaxWebClient " + key);
}
it.remove();
}
}
}
}
synchronized boolean finish() {
if (LOG.isDebugEnabled()) {
LOG.debug("Calling finish for " + sid);
}
if (!running) {
/*
* Avoids running finish() twice.
*/
return running;
}
running = false;
closeSocket(sock);
// channel = null;
this.interrupt();
if (recvWorker != null) {
recvWorker.finish();
}
if (LOG.isDebugEnabled()) {
LOG.debug("Removing entry from senderWorkerMap sid=" + sid);
}
senderWorkerMap.remove(sid, this);
threadCnt.decrementAndGet();
return running;
}
@Override
public boolean rename(Path src, Path dst) throws IOException {
// Attempt rename using Java API.
File srcFile = pathToFile(src);
File dstFile = pathToFile(dst);
if (srcFile.renameTo(dstFile)) {
return true;
}
// Enforce POSIX rename behavior that a source directory replaces an existing
// destination if the destination is an empty directory. On most platforms,
// this is already handled by the Java API call above. Some platforms
// (notably Windows) do not provide this behavior, so the Java API call above
// fails. Delete destination and attempt rename again.
if (this.exists(dst)) {
FileStatus sdst = this.getFileStatus(dst);
if (sdst.isDirectory() && dstFile.list().length == 0) {
if (LOG.isDebugEnabled()) {
LOG.debug("Deleting empty destination and renaming " + src + " to " + dst);
}
if (this.delete(dst, false) && srcFile.renameTo(dstFile)) {
return true;
}
}
}
// The fallback behavior accomplishes the rename by a full copy.
if (LOG.isDebugEnabled()) {
LOG.debug("Falling through to a copy of " + src + " to " + dst);
}
return FileUtil.copy(this, src, this, dst, true, getConf());
}
/**
* DOCUMENT ME!
*
* @param value DOCUMENT ME!
*/
private void setPointValue(final double value) {
if (isEditable()) {
if (LOG.isDebugEnabled()) {
LOG.debug("change bean value to " + value);
}
final CidsBean pointBean = getCidsBean();
final double oldValue = LinearReferencingHelper.getLinearValueFromStationBean(pointBean);
if (oldValue != value) {
try {
if (!isFeatureChangeLocked()) {
MAPPING_COMPONENT.getFeatureCollection().select(getFeature());
}
if (!isBeanChangeLocked()) {
LinearReferencingHelper.setLinearValueToStationBean(
(double) Math.round(value), pointBean);
}
} catch (Exception ex) {
if (LOG.isDebugEnabled()) {
LOG.debug("error changing bean", ex);
}
}
} else {
if (LOG.isDebugEnabled()) {
LOG.debug("no changes needed, old value was " + oldValue);
}
}
}
}
/** DOCUMENT ME! */
private void spinnerChanged() {
if (LOG.isDebugEnabled()) {
LOG.debug("spinner changed", new CurrentStackTrace());
}
try {
lockSpinnerChange(true);
final AbstractFormatter formatter =
((JSpinner.DefaultEditor) getValueSpinner().getEditor()).getTextField().getFormatter();
final String text =
((JSpinner.DefaultEditor) getValueSpinner().getEditor()).getTextField().getText();
if (!text.isEmpty()) {
try {
setPointValue((Double) formatter.stringToValue(text));
} catch (ParseException ex) {
if (LOG.isDebugEnabled()) {
LOG.debug("error parsing spinner", ex);
}
}
}
} finally {
lockSpinnerChange(false);
}
}
@Override
public Void call() throws IOException {
IOException toThrow = null;
StatisticsCollectionRunTracker collectionTracker =
StatisticsCollectionRunTracker.getInstance(config);
final HRegionInfo regionInfo = region.getRegionInfo();
try {
// update the statistics table
// Just verify if this if fine
ArrayList<Mutation> mutations = new ArrayList<Mutation>();
if (LOG.isDebugEnabled()) {
LOG.debug(
"Deleting the stats for the region "
+ regionInfo.getRegionNameAsString()
+ " as part of major compaction");
}
stats.deleteStats(region, tracker, family, mutations);
if (LOG.isDebugEnabled()) {
LOG.debug(
"Adding new stats for the region "
+ regionInfo.getRegionNameAsString()
+ " as part of major compaction");
}
stats.addStats(tracker, family, mutations);
if (LOG.isDebugEnabled()) {
LOG.debug(
"Committing new stats for the region "
+ regionInfo.getRegionNameAsString()
+ " as part of major compaction");
}
stats.commitStats(mutations);
} catch (IOException e) {
LOG.error("Failed to update statistics table!", e);
toThrow = e;
} finally {
try {
collectionTracker.removeCompactingRegion(regionInfo);
stats.close(); // close the writer
tracker.close(); // close the tracker
} catch (IOException e) {
if (toThrow == null) toThrow = e;
LOG.error("Error while closing the stats table", e);
} finally {
// close the delegate scanner
try {
delegate.close();
} catch (IOException e) {
if (toThrow == null) toThrow = e;
LOG.error("Error while closing the scanner", e);
} finally {
if (toThrow != null) {
throw toThrow;
}
}
}
}
return null;
}
@Override
public int update(AmPermission amPermission) {
if (LOG.isDebugEnabled()) {
LOG.debug(">>>>parameter:" + amPermission);
}
int result =
getSqlSession()
.update("org.framework.authorize.auth.mapper.AmPermissionMapper.update", amPermission);
if (LOG.isDebugEnabled()) {
LOG.debug(">>>>result:" + result);
}
return result;
}
@Override
public AmPermission getById(String permissionId) {
if (LOG.isDebugEnabled()) {
LOG.debug(">>>>parameter:" + permissionId);
}
AmPermission result =
getSqlSession()
.selectOne(
"org.framework.authorize.auth.mapper.AmPermissionMapper.getById", permissionId);
if (LOG.isDebugEnabled()) {
LOG.debug(">>>>result:" + result);
}
return result;
}
public boolean addResource(String url, String origin, String referrer) {
// We start the push period here and not when initializing the main resource, because a
// browser with a
// prefilled cache won't request the subresources. If the browser with warmed up cache now
// hits the main
// resource after a server restart, the push period shouldn't start until the first
// subresource is
// being requested.
firstResourceAdded.compareAndSet(-1, System.nanoTime());
long delay = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - firstResourceAdded.get());
if (!referrer.startsWith(origin) && !isPushOriginAllowed(origin)) {
if (LOG.isDebugEnabled())
LOG.debug(
"Skipped store of push metadata {} for {}: Origin: {} doesn't match or origin not allowed",
url,
name,
origin);
return false;
}
// This check is not strictly concurrent-safe, but limiting
// the number of associated resources is achieved anyway
// although in rare cases few more resources will be stored
if (resources.size() >= maxAssociatedResources) {
if (LOG.isDebugEnabled())
LOG.debug(
"Skipped store of push metadata {} for {}: max associated resources ({}) reached",
url,
name,
maxAssociatedResources);
return false;
}
if (delay > referrerPushPeriod) {
if (LOG.isDebugEnabled())
LOG.debug(
"Delay: {}ms longer than referrerPushPeriod ({}ms). Not adding resource: {} for: {}",
delay,
referrerPushPeriod,
url,
name);
return false;
}
if (LOG.isDebugEnabled()) LOG.debug("Adding: {} to: {} with delay: {}ms.", url, this, delay);
resources.add(url);
return true;
}
/**
* Remove the node from the runnable indices
*
* @param node node to remove
*/
public void deleteRunnable(ClusterNode node) {
String host = node.getHost();
if (LOG.isDebugEnabled()) {
LOG.debug(node.getName() + " deleted from runnable list for type: " + type);
}
NodeContainer nodeContainer = hostToRunnableNodes.get(host);
if (nodeContainer != null) {
synchronized (nodeContainer) {
if (nodeContainer.removeNode(node)) {
/**
* We are not removing the nodeContainer from runnable nodes map since we are
* synchronizing operations with runnable indices on it
*/
hostsWithRunnableNodes.decrementAndGet();
}
}
}
Node rack = node.hostNode.getParent();
nodeContainer = rackToRunnableNodes.get(rack);
if (nodeContainer != null) {
synchronized (nodeContainer) {
/**
* We are not removing the nodeContainer from runnable nodes map since we are
* synchronizing operations with runnable indices on it
*/
nodeContainer.removeNode(node);
}
}
}
public void run() {
zkLeader.start();
zkLeader.waitToBecomeLeader();
isMaster = true;
while (!stopped) {
long now = EnvironmentEdgeManager.currentTime();
// clear any expired
removeExpiredKeys();
if (lastKeyUpdate + keyUpdateInterval < now) {
// roll a new master key
rollCurrentKey();
}
try {
Thread.sleep(5000);
} catch (InterruptedException ie) {
if (LOG.isDebugEnabled()) {
LOG.debug("Interrupted waiting for next update", ie);
}
}
}
}
/**
* This method to check whether 'lookupreturn' is specified if lookupclass is selected.
*
* @param maintenanceDocument
* @return
*/
private boolean checkLookupReturn(MaintenanceDocument maintenanceDocument) {
if (LOG.isDebugEnabled()) {
LOG.debug(
"New maintainable is: " + maintenanceDocument.getNewMaintainableObject().getClass());
}
ProposalColumnsToAlter newEditableProposalField =
(ProposalColumnsToAlter) maintenanceDocument.getNewMaintainableObject().getDataObject();
if (StringUtils.isNotBlank(newEditableProposalField.getLookupClass())) {
GlobalVariables.getUserSession()
.addObject(
Constants.LOOKUP_CLASS_NAME, (Object) newEditableProposalField.getLookupClass());
}
if (StringUtils.isNotBlank(newEditableProposalField.getLookupClass())
&& StringUtils.isBlank(newEditableProposalField.getLookupReturn())) {
GlobalVariables.getMessageMap()
.putError(
Constants.PROPOSAL_EDITABLECOLUMN_LOOKUPRETURN,
RiceKeyConstants.ERROR_REQUIRED,
new String[] {"Lookup Return"});
return false;
}
return true;
}
void start() throws InterruptedException {
if (dependencies.size() > 0) {
synchronized (this) {
while (!canStart) {
this.wait(1000 * 60 * 3L);
if (dependenciesFailed) {
throw new TezUncheckedException(
"Skipping service start for "
+ service.getName()
+ " as dependencies failed to start");
}
}
}
}
if (LOG.isDebugEnabled()) {
LOG.debug("Service: " + service.getName() + " trying to start");
}
for (Service dependency : dependencies) {
if (!dependency.isInState(Service.STATE.STARTED)) {
LOG.info(
"Service: "
+ service.getName()
+ " not started because "
+ " service: "
+ dependency.getName()
+ " is in state: "
+ dependency.getServiceState());
return;
}
}
service.start();
}
/**
* This method is to check the existence of budgetcategorycode in table.
*
* @param maintenanceDocument
* @return
*/
private boolean checkExistence(MaintenanceDocument maintenanceDocument) {
boolean valid = true;
if (LOG.isDebugEnabled()) {
LOG.debug(
"new maintainable is: " + maintenanceDocument.getNewMaintainableObject().getClass());
}
// shared by budgetcategorymapping & costelement
// TODO : refactoring this - must have a better way to handle this sharing
String budgetCategoryCode;
if (maintenanceDocument.getNewMaintainableObject().getDataObject()
instanceof BudgetCategoryMapping) {
BudgetCategoryMapping budgetCategoryMapping =
(BudgetCategoryMapping) maintenanceDocument.getNewMaintainableObject().getDataObject();
budgetCategoryCode = budgetCategoryMapping.getBudgetCategoryCode();
} else {
CostElement costElement =
(CostElement) maintenanceDocument.getNewMaintainableObject().getDataObject();
budgetCategoryCode = costElement.getBudgetCategoryCode();
}
Map pkMap = new HashMap();
pkMap.put("code", budgetCategoryCode);
valid = checkExistenceFromTable(BudgetCategory.class, pkMap, "code", "Budget Category");
return valid;
}
/**
*
*
* <pre>
* Region-unittest,\x82\xB4\x85\xC2\x7F\xFF\xFE\xB6\xC9jNG\xEE!\x5C3\xBB\xAE\xA1:\x05\xA5\xA9x\xB0\xA1"8\x05\xFB(\xD2VY\xDB\x9A\x06\x09\xA9\x98\xC2\xE3\x8D=,1413960230654.aaf2a6c9f2c87c196f43497243bb2424.
* RegionID-unittest,1413960230654
* </pre>
*/
protected String getLogHeader() {
HRegion region = this.getCurrentRegion();
return LOG.isDebugEnabled()
? String.format("Region-%s", region.getRegionNameAsString())
: String.format(
"Region-%s,%d", region.getTableDesc().getNameAsString(), region.getRegionId());
}
@Override
public ByteBuffer next() {
try {
if (channel == null) {
channel = Files.newByteChannel(filePath, StandardOpenOption.READ);
LOG.debug("Opened file {}", filePath);
}
buffer.clear();
int read = channel.read(buffer);
if (read < 0) throw new NoSuchElementException();
if (LOG.isDebugEnabled()) LOG.debug("Read {} bytes from {}", read, filePath);
position += read;
if (!hasNext()) close();
buffer.flip();
return buffer;
} catch (NoSuchElementException x) {
close();
throw x;
} catch (Exception x) {
close();
throw (NoSuchElementException) new NoSuchElementException().initCause(x);
}
}
protected boolean mkOneDirWithMode(Path p, File p2f, FsPermission permission) throws IOException {
if (permission == null) {
return p2f.mkdir();
} else {
if (Shell.WINDOWS && NativeIO.isAvailable()) {
try {
NativeIO.Windows.createDirectoryWithMode(p2f, permission.toShort());
return true;
} catch (IOException e) {
if (LOG.isDebugEnabled()) {
LOG.debug(
String.format(
"NativeIO.createDirectoryWithMode error, path = %s, mode = %o",
p2f, permission.toShort()),
e);
}
return false;
}
} else {
boolean b = p2f.mkdir();
if (b) {
setPermission(p, permission);
}
return b;
}
}
}
@Override
public void exchangeTerminated(HttpExchange exchange, Result result) {
super.exchangeTerminated(exchange, result);
Response response = result.getResponse();
HttpFields responseHeaders = response.getHeaders();
String closeReason = null;
if (result.isFailed()) closeReason = "failure";
else if (receiver.isShutdown()) closeReason = "server close";
if (closeReason == null) {
if (response.getVersion().compareTo(HttpVersion.HTTP_1_1) < 0) {
// HTTP 1.0 must close the connection unless it has
// an explicit keep alive or it's a CONNECT method.
boolean keepAlive =
responseHeaders.contains(HttpHeader.CONNECTION, HttpHeaderValue.KEEP_ALIVE.asString());
boolean connect = HttpMethod.CONNECT.is(exchange.getRequest().getMethod());
if (!keepAlive && !connect) closeReason = "http/1.0";
} else {
// HTTP 1.1 or greater closes only if it has an explicit close.
if (responseHeaders.contains(HttpHeader.CONNECTION, HttpHeaderValue.CLOSE.asString()))
closeReason = "http/1.1";
}
}
if (closeReason != null) {
if (LOG.isDebugEnabled()) LOG.debug("Closing, reason: {} - {}", closeReason, connection);
connection.close();
} else {
if (response.getStatus() == HttpStatus.SWITCHING_PROTOCOLS_101) connection.remove();
else release();
}
}
/** Evaluate using classic parameter binding using the pre compute expression */
private Object evaluateParameterBinding(
Exchange exchange, Expression expression, int index, Class<?> parameterType) {
Object answer = null;
// use object first to avoid type conversion so we know if there is a value or not
Object result = expression.evaluate(exchange, Object.class);
if (result != null) {
try {
if (parameterType.isInstance(result)) {
// optimize if the value is already the same type
answer = result;
} else {
// we got a value now try to convert it to the expected type
answer =
exchange.getContext().getTypeConverter().mandatoryConvertTo(parameterType, result);
}
if (LOG.isTraceEnabled()) {
LOG.trace(
"Parameter #{} evaluated as: {} type: ",
new Object[] {index, answer, ObjectHelper.type(answer)});
}
} catch (NoTypeConversionAvailableException e) {
if (LOG.isDebugEnabled()) {
LOG.debug(
"Cannot convert from type: {} to type: {} for parameter #{}",
new Object[] {ObjectHelper.type(result), parameterType, index});
}
throw new ParameterBindingException(e, method, index, parameterType, result);
}
} else {
LOG.trace("Parameter #{} evaluated as null", index);
}
return answer;
}
/*
* check if custom attribute id is valid
*/
private boolean checkCustomAttributeExist(MaintenanceDocument maintenanceDocument) {
if (LOG.isDebugEnabled()) {
LOG.debug(
"new maintainable is: " + maintenanceDocument.getNewMaintainableObject().getClass());
}
CustomAttributeDocument newCustomAttributeDocument =
(CustomAttributeDocument) maintenanceDocument.getNewMaintainableObject().getDataObject();
if (newCustomAttributeDocument.getCustomAttributeId() != null) {
Map<String, String> queryMap = new HashMap<String, String>();
queryMap.put("id", newCustomAttributeDocument.getCustomAttributeId().toString());
if (getBoService().countMatching(CustomAttribute.class, queryMap) == 0) {
GlobalVariables.getMessageMap()
.putError(
Constants.DOCUMENT_NEWMAINTAINABLEOBJECT_CUSTOM_ATTRIBUTE_ID,
KeyConstants.ERROR_INVALID_CUSTOM_ATT_ID,
new String[] {newCustomAttributeDocument.getCustomAttributeId().toString()});
return false;
}
}
return true;
}
@Override
protected void onStateChanged() {
boolean isLeader = isLeader();
boolean hasLeader = hasLeader();
changeSupport.onLeadershipChange(isLeader, hasLeader);
treeChangeSupport.onLeadershipChange(isLeader, hasLeader);
// If this actor is no longer the leader close all the transaction chains
if (!isLeader) {
if (LOG.isDebugEnabled()) {
LOG.debug(
"{}: onStateChanged: Closing all transaction chains because shard {} is no longer the leader",
persistenceId(),
getId());
}
store.closeAllTransactionChains();
commitCoordinator.abortPendingTransactions(
"The transacton was aborted due to inflight leadership change.", this);
}
if (hasLeader && !isIsolatedLeader()) {
messageRetrySupport.retryMessages();
}
}
@Override
public void beansDropped(final ArrayList<CidsBean> beans) {
if (isEditable()) {
CidsBean routeBean = null;
for (final CidsBean bean : beans) {
if (bean.getMetaObject().getMetaClass().getName().equals(CN_ROUTE)) {
if ((getDropBehavior() == null) || getDropBehavior().checkForAdding(routeBean)) {
routeBean = bean;
setChangedSinceDrop(false);
}
double value = 0d;
if (isFirstStationInCurrentBB()) {
value = getPointInCurrentBB(routeBean);
}
setCidsBean(LinearReferencingHelper.createStationBeanFromRouteBean(routeBean, value));
if (isAutoZoomActivated) {
MapUtil.zoomToFeatureCollection(getZoomFeatures());
}
return;
}
}
if (LOG.isDebugEnabled()) {
LOG.debug("no route found in dropped objects");
}
}
}
private Parser detectParser(Record record) {
if (!hasAtLeastOneMimeType(record)) {
return null;
}
String mediaTypeStr =
(String)
record.getFirstValue(Fields.ATTACHMENT_MIME_TYPE); // ExtractingParams.STREAM_TYPE);
assert mediaTypeStr != null;
MediaType mediaType = parseMediaType(mediaTypeStr).getBaseType();
Parser parser = mediaTypeToParserMap.get(mediaType); // fast path
if (parser != null) {
return parser;
}
// wildcard matching
for (Map.Entry<MediaType, Parser> entry : mediaTypeToParserMap.entrySet()) {
if (isMediaTypeMatch(mediaType, entry.getKey())) {
return entry.getValue();
}
}
if (LOG.isDebugEnabled()) {
LOG.debug(
"No supported MIME type parser found for "
+ Fields.ATTACHMENT_MIME_TYPE
+ "="
+ mediaTypeStr);
}
return null;
}
/* Initiates a call by sending the parameter to the remote server.
* Note: this is not called from the Connection thread, but by other
* threads.
*/
protected void sendParam(Call call) {
if (shouldCloseConnection.get()) {
return;
}
// For serializing the data to be written.
final DataOutputBuffer d = new DataOutputBuffer();
try {
if (LOG.isDebugEnabled()) LOG.debug(getName() + " sending #" + call.id);
d.writeInt(0xdeadbeef); // placeholder for data length
d.writeInt(call.id);
call.param.write(d);
byte[] data = d.getData();
int dataLength = d.getLength();
// fill in the placeholder
Bytes.putInt(data, 0, dataLength - 4);
//noinspection SynchronizeOnNonFinalField
synchronized (this.out) { // FindBugs IS2_INCONSISTENT_SYNC
out.write(data, 0, dataLength);
out.flush();
}
} catch (IOException e) {
markClosed(e);
} finally {
// the buffer is just an in-memory buffer, but it is still polite to
// close early
IOUtils.closeStream(d);
}
}
@Override
protected Action process() throws Exception {
// Only return if EOF has previously been read and thus
// a write done with EOF=true
if (_eof) {
if (LOG.isDebugEnabled()) LOG.debug("EOF of {}", this);
// Handle EOF
_in.close();
closed();
_channel.getByteBufferPool().release(_buffer);
return Action.SUCCEEDED;
}
// Read until buffer full or EOF
int len = 0;
while (len < _buffer.capacity() && !_eof) {
int r = _in.read(_buffer.array(), _buffer.arrayOffset() + len, _buffer.capacity() - len);
if (r < 0) _eof = true;
else len += r;
}
// write what we have
_buffer.position(0);
_buffer.limit(len);
write(_buffer, _eof, this);
return Action.SCHEDULED;
}
@Override
public void onReceiveRecover(final Object message) throws Exception {
if (LOG.isDebugEnabled()) {
LOG.debug(
"{}: onReceiveRecover: Received message {} from {}",
persistenceId(),
message.getClass().toString(),
getSender());
}
if (message instanceof RecoveryFailure) {
LOG.error(
"{}: Recovery failed because of this cause",
persistenceId(),
((RecoveryFailure) message).cause());
// Even though recovery failed, we still need to finish our recovery, eg send the
// ActorInitialized message and start the txCommitTimeoutCheckSchedule.
onRecoveryComplete();
} else {
super.onReceiveRecover(message);
if (LOG.isTraceEnabled()) {
appendEntriesReplyTracker.begin();
}
}
}
