/** @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);
}
private void deadvertiseStream() {
// Don't deadvertise if we're shutting down
if (!mina.getCCM().isShuttingDown()) {
List<String> streamIds = new ArrayList<String>();
streamIds.add(streamId);
UnAdvSource uas = UnAdvSource.newBuilder().addAllStreamId(streamIds).build();
mina.getCCM().sendMessageToNetwork("UnAdvSource", uas);
}
}
/**
* Checks to see if we still want sources, and if we don't, notifies the network
*
* @syncpriority 200
*/
private boolean checkWantingSources() {
// Don't do anything if we are shutting down, when we disconnect the
// supernode will figure it out
if (mina.getCCM().isShuttingDown()) return false;
boolean wantingSources = false;
synchronized (this) {
wantingSources = ((listeners.size() != 0) || receiving);
}
if (!wantingSources) mina.getSourceMgr().dontWantSources(streamId);
return wantingSources;
}
public Set<String> getSourceNodeIds() {
Set<String> result = mina.getSourceMgr().getReadyNodeIds(streamId);
for (ConnectionPair lcp : streamConns.getAllListenConns()) {
result.add(lcp.getCC().getNodeDescriptor().getId());
}
return result;
}
/** Creates the bid strategy based on the class specified in the config file */
private void createBidStrategy() {
try {
bidStrategy =
(BidStrategy) Class.forName(mina.getConfig().getBidStrategyClass()).newInstance();
} catch (Exception e) {
throw new SeekInnerCalmException(e);
}
bidStrategy.setStreamMgr(this);
}
private void receptionCompleted() {
// Huzzah
log.info("Completed reception of " + getStreamId());
// If we want to become a broadcaster when reception is completed
// (probable), then there needs to be a receptionlistener that calls
// startbroadcast in response to this event
mina.getEventMgr().fireReceptionCompleted(getStreamId());
stopReception();
}
/** Don't use this ctor - use SMRegister.getOrCreateCM() instead */
public StreamMgr(MinaInstance mina, String streamId, PageBuffer pageBuf) {
this.mina = mina;
log = mina.getLogger(getClass());
this.streamId = streamId;
this.pageBuf = pageBuf;
streamConns = new StreamConnsMgr(this);
prm = new PageRequestMgr(this);
createBidStrategy();
}
/** @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());
}
}
/** @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 stopReception() {
log.info("Stopping reception for stream " + streamId);
if (!receiving) // Leftover thread
return;
receiving = false;
// If we're still wanting to hear about sources, keep track of the ones we're receiving from
if (checkWantingSources()) {
for (LCPair lcp : streamConns.getAllListenConns()) {
mina.getSourceMgr()
.cacheSourceUntilReady(lcp.getLastSourceStatus(), lcp.getLastStreamStatus());
}
}
streamConns.closeAllListenConns();
}
/** @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 requestCachedSources() {
if (!receiving) return;
Set<SourceStatus> sources = mina.getSourceMgr().getReadySources(streamId);
for (SourceStatus sourceStat : sources) {
// This is a bit kludgy - get the streamstatus that applies to us
StreamStatus streamStat = null;
for (StreamStatus testSs : sourceStat.getSsList()) {
if (testSs.getStreamId().equals(streamId)) {
streamStat = testSs;
break;
}
}
if (streamStat == null) throw new SeekInnerCalmException();
foundSource(sourceStat, streamStat);
}
}
private void notifyListenersOfSource(final String sourceId) {
final FoundSourceListener[] lisArr;
synchronized (this) {
lisArr = new FoundSourceListener[listeners.size()];
listeners.toArray(lisArr);
}
mina.getExecutor()
.execute(
new CatchingRunnable() {
public void doRun() throws Exception {
for (FoundSourceListener listener : lisArr) {
listener.foundBroadcaster(streamId, sourceId);
}
}
});
}
/** @syncpriority 160 */
public int numSources() {
int result = mina.getSourceMgr().numReadySources(streamId);
result += streamConns.getNumListenConns();
return result;
}
/** @syncpriority 200 */
public synchronized void abort() {
streamConns.abort();
mina.getSmRegister().unregisterSM(streamId);
}
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);
}
}
/** @syncpriority 200 */
public synchronized void startRebroadcast() {
if (rebroadcasting) throw new SeekInnerCalmException();
rebroadcasting = true;
log.info("Beginning rebroadcast for stream " + streamId);
mina.getStreamAdvertiser().advertiseStream(streamId);
}
/** @syncpriority 200 */
public synchronized void addFoundSourceListener(FoundSourceListener listener) {
boolean sendWantSources = (listeners.size() == 0);
listeners.add(listener);
if (sendWantSources) mina.getSourceMgr().wantSources(streamId, tolerateDelay());
}