/** @syncpriority 200 */
public synchronized void startBroadcast() {
if (broadcasting) throw new SeekInnerCalmException();
log.debug("Starting pagebuffer for " + streamId);
pageBuf.start();
broadcasting = true;
log.info("Starting broadcast of " + pageBuf.getTotalPages() + " pages for " + streamId);
// If we're already rebroadcasting, this means that we've completed
// reception and are now a broadcaster - so we don't need to announce
// ourselves again
if (rebroadcasting) rebroadcasting = false;
else mina.getStreamAdvertiser().advertiseStream(streamId);
}
public StreamStatus buildStreamStatus(String toNodeId) {
StreamStatus.Builder bldr = StreamStatus.newBuilder();
if (toNodeId != null) {
bldr.setToNodeId(toNodeId);
bldr.setFromNodeId(mina.getMyNodeId());
}
bldr.setStreamId(streamId);
if (pageBuf.getTotalPages() > 0) bldr.setTotalPages(pageBuf.getTotalPages());
StreamPosition sp = pageBuf.getStreamPosition();
bldr.setLastContiguousPage(sp.getLastContiguousPage());
if (sp.getPageMap() > 0) bldr.setPageMap(sp.getPageMap());
return bldr.build();
}
/** @syncpriority 200 */
public synchronized void stop() {
log.debug("SM for " + streamId + " stopping");
if (broadcasting) stopBroadcast();
if (rebroadcasting) stopRebroadcast();
if (receiving) stopReception();
listeners.clear();
checkWantingSources();
streamConns.closeAll();
mina.getSmRegister().unregisterSM(streamId);
if (pageBuf != null) {
pageBuf.stop();
pageBuf.close();
}
}
/** @syncpriority 200 */
public void notifyDeadConnection(ConnectionPair pair) {
synchronized (this) {
streamConns.removeConnectionPair(pair);
if (pair instanceof LCPair) {
prm.notifyDeadConnection(pair.getCC().getNodeId());
if (streamConns.getNumListenConns() < mina.getConfig().getMaxSources())
requestCachedSources();
bidStrategy.cleanup(pair.getCC().getNodeId());
// Make note of them in case they come back
LCPair lcp = (LCPair) pair;
SourceStatus sourceStat = lcp.getLastSourceStatus();
if (sourceStat != null) {
StreamStatus streamStat = lcp.getLastStreamStatus();
if (streamStat == null) throw new SeekInnerCalmException();
mina.getSourceMgr().cachePossiblyDeadSource(sourceStat, streamStat);
}
}
if (streamConns.getNumBroadcastConns() == 0 && streamConns.getNumListenConns() == 0) {
try {
pageBuf.sleep();
} catch (IOException e) {
log.error("Error sleeping page buffer", e);
stop();
}
}
}
if (isReceiving()) mina.getEventMgr().fireReceptionConnsChanged(streamId);
}
/** @syncpriority 200 */
public void receivePage(Page p) {
synchronized (this) {
// We might have already stopped receiving, in which case the
// pagebuf will be closed
if (!isReceiving()) return;
try {
pageBuf.putPage(p);
} catch (IOException e) {
log.error("Error putting page into buffer", e);
stop();
return;
}
}
prm.notifyPageReceived(p.getPageNumber());
updateStreamStatus();
if (isReceiving() && !isRebroadcasting()) startRebroadcast();
if (pageBuf.getLastContiguousPage() == (pageBuf.getTotalPages() - 1)) receptionCompleted();
}
/** @syncpriority 200 */
public synchronized void startReception() {
if (receiving) throw new SeekInnerCalmException();
// If we're already finished, just start rebroadcasting
if (pageBuf.isComplete()) startRebroadcast();
else {
receiving = true;
requestCachedSources();
mina.getSourceMgr().wantSources(streamId, tolerateDelay());
}
}
public void setPageBuffer(PageBuffer pageBuf) {
this.pageBuf = pageBuf;
if (pageBuf.getTotalPages() <= 0) pageBuf.setTotalPages(totalPages);
}
public void foundSource(SourceStatus sourceStat, StreamStatus streamStat) {
String fromNodeId = sourceStat.getFromNode().getId();
String sourceId = fromNodeId;
if (streamStat.getTotalPages() != 0) {
long totalPages = streamStat.getTotalPages();
if (pageBuf == null) this.totalPages = totalPages;
else {
if (pageBuf.getTotalPages() <= 0) pageBuf.setTotalPages(totalPages);
else {
if (pageBuf.getTotalPages() != totalPages) {
log.error(
"Node "
+ sourceId
+ " advertised total pages "
+ totalPages
+ " for stream "
+ streamId
+ ", but I have already recorded "
+ pageBuf.getTotalPages());
return;
}
}
}
}
if (streamConns.haveListenConnWithId(sourceId)) return;
// If we're not receiving, then we're just caching sources to pass to an external listener - so
// cache it
if (!receiving) {
mina.getSourceMgr().cacheSourceUntilReady(sourceStat, streamStat);
notifyListenersOfSource(sourceId);
return;
}
// Not listening to this node - let's see if we should
if (mina.getConfig().isAgoric()) {
if (!bidStrategy.worthConnectingTo(new AuctionState(sourceStat.getAuctionState()))) {
log.debug(
"Not connecting to node " + sourceId + " for " + streamId + " - bid strategy says no");
mina.getSourceMgr().cacheSourceUntilAgoricsAcceptable(sourceStat, streamStat);
return;
}
}
// Check that they have data useful to us
if (pageBuf != null) {
StreamPosition sp =
new StreamPosition(streamStat.getLastContiguousPage(), streamStat.getPageMap());
if (sp.highestIncludedPage() <= pageBuf.getLastContiguousPage()) {
// Useless at the moment - cache them and ask again later
mina.getSourceMgr().cacheSourceUntilDataAvailable(sourceStat, streamStat);
return;
}
}
// This is a useful source - let our listeners know
notifyListenersOfSource(sourceId);
if (streamConns.getNumListenConns() >= mina.getConfig().getMaxSources()) {
mina.getSourceMgr().cacheSourceUntilReady(sourceStat, streamStat);
return;
}
try {
streamConns.makeListenConnectionTo(sourceStat);
} catch (MinaConnectionException e) {
log.error("Caught MinaConnectionException when attempting to connect to " + sourceId);
}
}