//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private org.neo4j.cursor.IOCursor<org.neo4j.kernel.impl.transaction.CommittedTransactionRepresentation> getCursor(long txIdPromise, io.netty.channel.ChannelHandlerContext ctx, long firstTxId, org.neo4j.causalclustering.identity.StoreId localStoreId, org.neo4j.causalclustering.identity.StoreId expectedStoreId) throws java.io.IOException
private IOCursor <CommittedTransactionRepresentation> GetCursor(long txIdPromise, ChannelHandlerContext ctx, long firstTxId, StoreId localStoreId, StoreId expectedStoreId)
{
if (localStoreId == null || !localStoreId.Equals(expectedStoreId))
{
_log.info("Failed to serve TxPullRequest for tx %d and storeId %s because that storeId is different " + "from this machine with %s", firstTxId, expectedStoreId, localStoreId);
EndInteraction(ctx, E_STORE_ID_MISMATCH, txIdPromise);
return(null);
}
else if (!_databaseAvailable.AsBoolean)
{
_log.info("Failed to serve TxPullRequest for tx %d because the local database is unavailable.", firstTxId);
EndInteraction(ctx, E_STORE_UNAVAILABLE, txIdPromise);
return(null);
}
else if (txIdPromise < firstTxId)
{
EndInteraction(ctx, SUCCESS_END_OF_STREAM, txIdPromise);
return(null);
}
try
{
return(_logicalTransactionStore.getTransactions(firstTxId));
}
catch (NoSuchTransactionException)
{
_log.info("Failed to serve TxPullRequest for tx %d because the transaction does not exist.", firstTxId);
EndInteraction(ctx, E_TRANSACTION_PRUNED, txIdPromise);
return(null);
}
}
public override Fallible <BackupStageOutcome> PerformFullBackup(DatabaseLayout targetDatabaseLayout, Config config, OptionalHostnamePort userProvidedAddress)
{
AdvertisedSocketAddress fromAddress = _addressResolver.resolveCorrectCCAddress(config, userProvidedAddress);
_log.info("Resolved address for catchup protocol is " + fromAddress);
StoreId storeId;
try
{
storeId = _backupDelegator.fetchStoreId(fromAddress);
_log.info("Remote store id is " + storeId);
}
catch (StoreIdDownloadFailedException e)
{
return(new Fallible <BackupStageOutcome>(BackupStageOutcome.WrongProtocol, e));
}
Optional <StoreId> expectedStoreId = ReadLocalStoreId(targetDatabaseLayout);
if (expectedStoreId.Present)
{
return(new Fallible <BackupStageOutcome>(BackupStageOutcome.Failure, new StoreIdDownloadFailedException(format("Cannot perform a full backup onto preexisting backup. Remote store id was %s but local is %s", storeId, expectedStoreId))));
}
try
{
_backupDelegator.copy(fromAddress, storeId, targetDatabaseLayout);
return(new Fallible <BackupStageOutcome>(BackupStageOutcome.Success, null));
}
catch (StoreCopyFailedException e)
{
return(new Fallible <BackupStageOutcome>(BackupStageOutcome.Failure, e));
}
}
public override void Print(string name)
{
string accessStr = _accessStatistics.AccessStatSummary;
_logger.info(format("=== %s ===", name));
_logger.info(format("I/Os%n%s", accessStr));
_logger.info(_counts.ToString());
_logger.info(MemoryStats());
_logger.info("Done in " + Format.duration(currentTimeMillis() - _startTime));
}
public virtual void Start()
{
lock (this)
{
_log.info("Starting log shipper: %s", StatusAsString());
SendEmpty(_raftLog.appendIndex(), _lastLeaderContext);
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public final synchronized void enable() throws Throwable
public override void Enable()
{
lock (this)
{
if (!_stoppedByLifeCycle)
{
Start0();
}
else
{
_debugLog.info("%s will not start. It was enabled but is stopped by lifecycle", this);
}
_enabled = true;
}
}
public override void Validate()
{
if (_backupHelper.successfulBackups.get() == 0)
{
throw new System.InvalidOperationException("Failed to perform any backups");
}
_log.info(string.Format("Performed {0:D}/{1:D} successful backups.", _backupHelper.successfulBackups.get(), _backupHelper.backupNumber.get()));
}
public override void Dispose()
{
lock (this)
{
_log.info("Disposing channel: " + _channel);
_disposed = true;
_channel.close();
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public org.neo4j.causalclustering.core.consensus.outcome.Outcome handle(org.neo4j.causalclustering.core.consensus.RaftMessages_Heartbeat req) throws java.io.IOException
public override Outcome Handle(Org.Neo4j.causalclustering.core.consensus.RaftMessages_Heartbeat req)
{
if (req.LeaderTerm() < Ctx.term())
{
return(Outcome);
}
Outcome.NextRole = FOLLOWER;
Log.info("Moving to FOLLOWER state after receiving heartbeat from %s at term %d (I am at %d)", req.From(), req.LeaderTerm(), Ctx.term());
Heart.Beat(Ctx, Outcome, req, Log);
return(Outcome);
}
/// <summary>
/// Performs a switch to the master state. Starts communication endpoints, switches components to the master state
/// and broadcasts the appropriate Master Is Available event. </summary>
/// <param name="haCommunicationLife"> The LifeSupport instance to register communication endpoints. </param>
/// <param name="me"> The URI that the communication endpoints should bind to </param>
/// <returns> The URI at which the master communication was bound. </returns>
//JAVA TO C# CONVERTER NOTE: Members cannot have the same name as their enclosing type:
public virtual URI SwitchToMasterConflict(LifeSupport haCommunicationLife, URI me)
{
_userLog.info("I am %s, moving to master", MyId(_config));
// Do not wait for currently active transactions to complete before continuing switching.
// - A master in a cluster is very important, without it the cluster cannot process any write requests
// - Awaiting open transactions to complete assumes that this instance just now was a slave that is
// switching to master, which means the previous master where these active transactions were hosted
// is no longer available so these open transactions cannot continue and complete anyway,
// so what's the point waiting for them?
// - Read transactions may still be able to complete, but the correct response to failures in those
// is to have them throw transient error exceptions hinting that they should be retried,
// at which point they may get redirected to another instance, or to this instance if it has completed
// the switch until then.
_idGeneratorFactory.switchToMaster();
NeoStoreDataSource dataSource = _dataSourceSupplier.get();
dataSource.AfterModeSwitch();
Locks locks = dataSource.DependencyResolver.resolveDependency(typeof(Locks));
ConversationManager conversationManager = ConversationManagerFactory.apply(locks);
Master master = MasterFactory.apply(conversationManager, haCommunicationLife);
MasterServer masterServer = MasterServerFactory.apply(master, conversationManager);
haCommunicationLife.Add(masterServer);
_masterDelegateHandler.Delegate = master;
haCommunicationLife.Start();
URI masterHaURI = GetMasterUri(me, masterServer, _config);
_clusterMemberAvailability.memberIsAvailable(MASTER, masterHaURI, dataSource.StoreId);
_userLog.info("I am %s, successfully moved to master", MyId(_config));
_slaveFactorySupplier.get().StoreId = dataSource.StoreId;
return(masterHaURI);
}
public override void Init()
{
_logger.info("Initiating metrics...");
if (_metricsBuilt && _reporter.Empty)
{
_logger.warn("Several metrics were enabled but no exporting option was configured to report values to. " + "Disabling kernel metrics extension.");
_life.clear();
}
if (!_reporter.Empty && !_metricsBuilt)
{
_logger.warn("Exporting tool have been configured to report values to but no metrics were enabled. " + "Disabling kernel metrics extension.");
_life.clear();
}
_life.init();
}
private void TryConnect()
{
lock (this)
{
if (_disposed)
{
return;
}
else if (_fChannel != null && !_fChannel.Done)
{
return;
}
_fChannel = _bootstrap.connect(_destination.socketAddress());
_channel = _fChannel.channel();
_fChannel.addListener((ChannelFuture f) =>
{
if (!f.Success)
{
long millis = _connectionBackoff.Millis;
_cappedLogger.warn("Failed to connect to: " + _destination.socketAddress() + ". Retrying in " + millis + " ms");
f.channel().eventLoop().schedule(this.tryConnect, millis, MILLISECONDS);
_connectionBackoff.increment();
}
else
{
_log.info("Connected: " + f.channel());
f.channel().closeFuture().addListener(closed =>
{
_log.warn(string.Format("Lost connection to: {0} ({1})", _destination, _channel.remoteAddress()));
_connectionBackoff = _connectionBackoffStrategy.newTimeout();
f.channel().eventLoop().schedule(this.tryConnect, 0, MILLISECONDS);
});
}
});
}
}
protected internal override void ChannelRead0(ChannelHandlerContext ctx, FileHeader fileHeader)
{
_log.info("Receiving file: %s", fileHeader.FileName());
_handler.onFileHeader(fileHeader);
_protocol.expect(State.FILE_CONTENTS);
}
public override void Visit(ResourceType resourceType, long resourceId, string description, long estimatedWaitTime, long lockIdentityHashCode)
{
_log.info("%s{id=%d, waitTime=%d, description=%s, lockHash=%d}", resourceType, resourceId, estimatedWaitTime, description, lockIdentityHashCode);
}
// Cluster events
/// <summary>
/// Logged when the instance itself joins or rejoins a cluster
/// </summary>
/// <param name="clusterConfiguration"> </param>
public override void EnteredCluster(ClusterConfiguration clusterConfiguration)
{
_myUri = clusterConfiguration.GetUriForId(_myId);
_log.info("Instance %s entered the cluster", PrintId(_myId, _myUri));
}
public override void StartReceivingStoreFiles()
{
_log.info("Start receiving store files");
}
public override void WarmupStarted()
{
_warmupStartMillis = currentTimeMillis();
_log.info("Page cache warmup started.");
}
public override void Started(int numStages)
{
this._numStages = numStages;
_log.info(MESSAGE_STARTED);
_startTime = _clock.millis();
}