//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public static void restoreFromBackup(java.io.File backup, org.neo4j.io.fs.FileSystemAbstraction fsa, org.neo4j.causalclustering.discovery.ClusterMember clusterMember) throws java.io.IOException, org.neo4j.commandline.admin.CommandFailed
public static void RestoreFromBackup(File backup, FileSystemAbstraction fsa, ClusterMember clusterMember)
{
Config config = clusterMember.config();
RestoreDatabaseCommand restoreDatabaseCommand = new RestoreDatabaseCommand(fsa, backup, config, GraphDatabaseSettings.DEFAULT_DATABASE_NAME, true);
restoreDatabaseCommand.Execute();
}
private static BinaryLatch InjectWarmupLatch( ClusterMember member, AtomicLong pagesLoadedInWarmup )
{
BinaryLatch warmupLatch = new BinaryLatch();
Monitors monitors = member.monitors();
monitors.AddMonitorListener( new PageCacheWarmerMonitorAdapterAnonymousInnerClass( pagesLoadedInWarmup, warmupLatch ) );
return warmupLatch;
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public void doWorkOnMember(org.neo4j.causalclustering.discovery.ClusterMember oldMember) throws Exception
public override void DoWorkOnMember(ClusterMember oldMember)
{
bool replaceFromBackup = ThreadLocalRandom.current().nextBoolean();
File backup = null;
if (replaceFromBackup)
{
backup = CreateBackupWithRetries(oldMember);
}
_log.info("Stopping: " + oldMember);
oldMember.shutdown();
ClusterMember newMember = (oldMember is CoreClusterMember) ? _cluster.newCoreMember() : _cluster.newReadReplica();
if (replaceFromBackup)
{
_log.info("Restoring backup: " + backup.Name + " to: " + newMember);
restoreFromBackup(backup, _fs, newMember);
_fs.deleteRecursively(backup);
}
_log.info("Starting: " + newMember);
newMember.start();
_successfulReplacements++;
}
/// <summary>
/// Performs a backup and returns the path to it. Benign failures are swallowed and an empty optional gets returned.
/// </summary>
/// <param name="member"> The member to perform the backup against. </param>
/// <returns> The optional backup. </returns>
/// <exception cref="Exception"> If any unexpected exceptions happen. </exception>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: java.util.Optional<java.io.File> backup(org.neo4j.causalclustering.discovery.ClusterMember member) throws Exception
internal virtual Optional <File> Backup(ClusterMember member)
{
AdvertisedSocketAddress address = member.config().Get(transaction_advertised_address);
string backupName = "backup-" + BackupNumber.AndIncrement;
OnlineBackupCommandBuilder backupCommand = (new OnlineBackupCommandBuilder()).withOutput(NULL_OUTPUT_STREAM).withSelectedBackupStrategy(CATCHUP).withConsistencyCheck(true).withHost(address.Hostname).withPort(address.Port);
try
{
backupCommand.Backup(_baseBackupDir, backupName);
_log.info(string.Format("Created backup {0} from {1}", backupName, member));
SuccessfulBackups.incrementAndGet();
return(new File(_baseBackupDir, backupName));
}
catch (CommandFailed e)
{
Optional <Exception> benignException = findCauseOrSuppressed(e, t => _benignExceptions.Contains(t.GetType()));
if (benignException.Present)
{
_log.info("Benign failure: " + benignException.get().Message);
}
else
{
throw e;
}
}
return(null);
}
/// <summary>
/// Immediately terminates the processing of all client messages.
/// </summary>
public void Stop()
{
if (router == null)
{
return;
}
using (TimedLock.Lock(syncLock))
{
if (packageFolder != null)
{
packageFolder.Dispose();
packageFolder = null;
}
if (bkTimer != null)
{
bkTimer.Dispose();
bkTimer = null;
}
if (cluster != null)
{
cluster.Stop();
cluster = null;
}
if (router != null)
{
router.Dispatcher.RemoveTarget(this);
router = null;
}
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private java.io.File createBackupWithRetries(org.neo4j.causalclustering.discovery.ClusterMember member) throws Exception
private File CreateBackupWithRetries(ClusterMember member)
{
int failureCount = 0;
while (true)
{
Optional <File> backupOpt = _backupHelper.backup(member);
if (backupOpt.Present)
{
return(backupOpt.get());
}
else
{
failureCount++;
if (failureCount >= MAX_BACKUP_FAILURES)
{
throw new Exception(format("Backup failed %s times in a row.", failureCount));
}
_log.info("Retrying backup in %s ms.", RETRY_TIMEOUT_MILLIS);
Thread.Sleep(RETRY_TIMEOUT_MILLIS);
}
}
}
//---------------------------------------
// Clustering Implementation Note:
//
// Note that the one of the application store instances in the cluster needs
// to be configured as the primary application store. This is done by setting
// the following configuration setting:
//
// LillTek.Datacenter.AppStore = Primary
//
// The primary application store holds the definitive set of application
// packages against which the non-primary store instances will synchronize
// themselves. Note that the primary application store is not necessarily
// the cluster master. These two concepts are independent. The cluster master
// will be elected normally from the pool of application store instances and
// will be responsible for replicating cluster state global and instance state.
//
// At this point there is no global cluster state. Each instance does expose
// the following properties to the cluster:
//
// Mode This is set to "Primary" or "Cache" and indicates which
// application store instances are configured to be the
// primary instance (For this implementation, only one
// instance should be configured as the primary).
/// <summary>
/// Constructs a application store service handler instance.
/// </summary>
public AppStoreHandler()
{
this.router = null;
this.syncLock = null;
this.bkTimer = null;
this.cluster = null;
}
private static void VerifyWarmupHappensAfterStoreCopy( ClusterMember member, long pagesInMemory )
{
AtomicLong pagesLoadedInWarmup = new AtomicLong();
BinaryLatch warmupLatch = InjectWarmupLatch( member, pagesLoadedInWarmup );
member.start();
warmupLatch.Await();
// Check that we warmup up all right:
assertThat( pagesLoadedInWarmup.get(), greaterThanOrEqualTo(pagesInMemory) );
}
private void ZyreExitEvent(object sender, ZyreEventExit e)
{
// A peer node has left the cluster
ClusterMember.Raise(this, ClusterMemberEvent.ExitingEvent, new ClusterMemberEvent
{
NodeId = e.SenderName,
NetworkNodeId = e.SenderUuid.ToString()
});
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public void doWorkOnMember(org.neo4j.causalclustering.discovery.ClusterMember member) throws Exception
public override void DoWorkOnMember(ClusterMember member)
{
Optional <File> backupDir = _backupHelper.backup(member);
if (backupDir.Present)
{
_fs.deleteRecursively(backupDir.get());
}
}
// Allows you to a one new member.
public void Add(int key, ClusterMember member)
{
if (Dic.TryGetValue(key, out var memberList)) {
memberList.Add(member);
} else {
memberList = new List<ClusterMember> { member };
Dic.Add(key, memberList);
}
}
private void AwaitIndexOnline(ClusterMember member)
{
GraphDatabaseAPI db = member.database();
using (Transaction tx = Db.beginTx())
{
Db.schema().awaitIndexesOnline(1, TimeUnit.MINUTES);
tx.Success();
}
}
/// <summary>
/// Constructor.
/// </summary>
public DynDnsClient()
{
this.syncLock = this;
this.isOpen = false;
this.router = null;
this.cluster = null;
this.enabled = false;
this.settings = null;
this.bkTimer = null;
this.hosts = new Dictionary <DynDnsHostEntry, DynDnsHostEntry>();
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public void doWorkOnMember(org.neo4j.causalclustering.discovery.ClusterMember member) throws Exception
public override void DoWorkOnMember(ClusterMember member)
{
File databaseDirectory = member.database().DatabaseLayout().databaseDirectory();
_log.info("Stopping: " + member);
member.shutdown();
assertStoreConsistent(_fileSystem, databaseDirectory);
Thread.Sleep(5000);
_log.info("Starting: " + member);
member.start();
}
private long?TxId(ClusterMember member)
{
try
{
GraphDatabaseAPI database = member.database();
TransactionIdStore txIdStore = database.DependencyResolver.resolveDependency(typeof(TransactionIdStore), ONLY);
return(long?.of(txIdStore.LastClosedTransactionId));
}
catch (Exception)
{
return(long?.empty());
}
}
private static System.Func <ClusterMembers> GetClusterMembers(string memberRole, HighAvailabilityMemberState memberState)
{
HighAvailabilityMemberStateMachine stateMachine = mock(typeof(HighAvailabilityMemberStateMachine));
when(stateMachine.CurrentState).thenReturn(memberState);
ClusterMember clusterMember = spy(new ClusterMember(new InstanceId(1)));
when(clusterMember.HARole).thenReturn(memberRole);
ObservedClusterMembers observedClusterMembers = mock(typeof(ObservedClusterMembers));
when(observedClusterMembers.CurrentMember).thenReturn(clusterMember);
return(() => new ClusterMembers(observedClusterMembers, stateMachine));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("unchecked") private SwitchToSlaveCopyThenBranch newSwitchToSlaveSpy(org.neo4j.io.pagecache.PageCache pageCacheMock, org.neo4j.com.storecopy.StoreCopyClient storeCopyClient)
private SwitchToSlaveCopyThenBranch NewSwitchToSlaveSpy(PageCache pageCacheMock, StoreCopyClient storeCopyClient)
{
ClusterMembers clusterMembers = mock(typeof(ClusterMembers));
ClusterMember master = mock(typeof(ClusterMember));
when(master.StoreId).thenReturn(_storeId);
when(master.HARole).thenReturn(HighAvailabilityModeSwitcher.MASTER);
when(master.HasRole(eq(HighAvailabilityModeSwitcher.MASTER))).thenReturn(true);
when(master.InstanceId).thenReturn(new InstanceId(1));
when(clusterMembers.Members).thenReturn(asList(master));
Dependencies resolver = new Dependencies();
DatabaseAvailability databaseAvailability = mock(typeof(DatabaseAvailability));
when(databaseAvailability.Started).thenReturn(true);
resolver.SatisfyDependencies(_requestContextFactory, clusterMembers, mock(typeof(TransactionObligationFulfiller)), mock(typeof(OnlineBackupKernelExtension)), mock(typeof(IndexConfigStore)), mock(typeof(TransactionCommittingResponseUnpacker)), mock(typeof(DataSourceManager)), mock(typeof(StoreLockerLifecycleAdapter)), mock(typeof(FileSystemWatcherService)), databaseAvailability);
NeoStoreDataSource dataSource = mock(typeof(NeoStoreDataSource));
when(dataSource.StoreId).thenReturn(_storeId);
when(dataSource.DependencyResolver).thenReturn(resolver);
DatabaseTransactionStats transactionCounters = mock(typeof(DatabaseTransactionStats));
when(transactionCounters.NumberOfActiveTransactions).thenReturn(0L);
Response <HandshakeResult> response = mock(typeof(Response));
when(response.ResponseConflict()).thenReturn(new HandshakeResult(42, 2));
when(_masterClient.handshake(anyLong(), any(typeof(StoreId)))).thenReturn(response);
when(_masterClient.ProtocolVersion).thenReturn(Org.Neo4j.Kernel.ha.com.slave.MasterClient_Fields.Current);
TransactionIdStore transactionIdStoreMock = mock(typeof(TransactionIdStore));
// note that the checksum (the second member of the array) is the same as the one in the handshake mock above
when(transactionIdStoreMock.LastCommittedTransaction).thenReturn(new TransactionId(42, 42, 42));
MasterClientResolver masterClientResolver = mock(typeof(MasterClientResolver));
when(masterClientResolver.Instantiate(anyString(), anyInt(), anyString(), any(typeof(Monitors)), argThat(_storeId => true), any(typeof(LifeSupport)))).thenReturn(_masterClient);
return(spy(new SwitchToSlaveCopyThenBranch(TestDirectory.databaseLayout(), NullLogService.Instance, ConfigMock(), mock(typeof(HaIdGeneratorFactory)), mock(typeof(DelegateInvocationHandler)), mock(typeof(ClusterMemberAvailability)), _requestContextFactory, _pullerFactory, masterClientResolver, mock(typeof(SwitchToSlave.Monitor)), storeCopyClient, Suppliers.singleton(dataSource), Suppliers.singleton(transactionIdStoreMock), slave =>
{
SlaveServer server = mock(typeof(SlaveServer));
InetSocketAddress inetSocketAddress = InetSocketAddress.createUnresolved("localhost", 42);
when(server.SocketAddress).thenReturn(inetSocketAddress);
return server;
}, _updatePuller, pageCacheMock, mock(typeof(Monitors)), () => transactionCounters)));
}
private bool TryMatchSilo(V1Pod pod, out ClusterMember server)
{
var snapshot = _clusterMembershipService.CurrentSnapshot;
foreach (var member in snapshot.Members)
{
if (string.Equals(member.Value.Name, pod.Metadata.Name, StringComparison.Ordinal))
{
server = member.Value;
return(true);
}
}
server = default;
return(false);
}
private void WaitForOnline(ClusterMember cluster, TimeSpan timeout)
{
DateTime exitTime = SysTime.Now + timeout + TimeSpan.FromSeconds(2);
while (SysTime.Now < exitTime)
{
if (cluster.IsOnline)
{
return;
}
Thread.Sleep(50);
}
throw new TimeoutException("Timeout waiting for [IsOnline]");
}
internal virtual void VisitAllIds(ClusterMember member, System.Action <long> idConsumer)
{
DatabaseLayout databaseLayout = DatabaseLayout.of(member.databaseDirectory());
File idFile = databaseLayout.IdNodeStore();
IdContainer idContainer = new IdContainer(Fs, idFile, 1024, true);
idContainer.Init();
Log.info(idFile.AbsolutePath + " has " + idContainer.FreeIdCount + " free ids");
long id = idContainer.ReusableId;
while (id != IdContainer.NO_RESULT)
{
idConsumer(id);
id = idContainer.ReusableId;
}
idContainer.Close(0);
}
/// <summary>
/// returns the mapping of changes (old memberId--> new RuntimeMember).
/// </summary>
/// <param name="clusterMembers">codex members</param>
/// <param name="runtimeMembers">runtime members</param>
/// <returns>the mapping</returns>
public static Dictionary <string, ClusterMember> GetMapping(List <ClusterMember> clusterMembers, List <ClusterMember> runtimeMembers)
{
if (clusterMembers == null)
{
throw new ArgumentNullException("clusterMembers");
}
if (runtimeMembers == null)
{
throw new ArgumentNullException("runtimeMembers");
}
Dictionary <string, ClusterMember> mapping = new Dictionary <string, ClusterMember>();
for (int i = 0; i < clusterMembers.Count; i++)
{
// select the codex member in the array
ClusterMember codexMember = clusterMembers[i];
// locate the runtime memberset from the list for this codex member
ClusterMember m = runtimeMembers.Single(c => c.MemberId == codexMember.MemberId);
if (m.Address.Equals(codexMember.Address))
{
continue;
}
mapping.Add(m.MemberId, m);
}
// now we add any runtime member that is not in the original mapping (i.e. we are doing a scale out).
foreach (ClusterMember m in runtimeMembers)
{
if (!mapping.ContainsKey(m.MemberId))
{
mapping.Add(m.MemberId, m);
}
}
return(mapping);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldReturnUnavailableStatusWhenDoingLongOperation()
public virtual void ShouldReturnUnavailableStatusWhenDoingLongOperation()
{
// given
ClusterMember member = _cluster.getCoreMemberById(1);
// when
member.database().DependencyResolver.resolveDependency(typeof(DatabaseAvailabilityGuard)).require(() => "Not doing long operation");
// then
try
{
using (Transaction tx = member.database().BeginTx())
{
tx.Success();
fail();
}
}
catch (Exception e)
{
assertEquals(Org.Neo4j.Kernel.Api.Exceptions.Status_General.DatabaseUnavailable, statusCodeOf(e));
}
}
private ObservedClusterMembers MockClusterMembers(InstanceId me, IList <InstanceId> alive, IList <InstanceId> failed)
{
ObservedClusterMembers members = mock(typeof(ObservedClusterMembers));
// we cannot set outside of the package the isAlive to return false. So do it with a mock
IList <ClusterMember> aliveMembers = new List <ClusterMember>(alive.Count);
IList <ClusterMember> failedMembers = new List <ClusterMember>(failed.Count);
foreach (InstanceId instanceId in alive)
{
ClusterMember otherMember = mock(typeof(ClusterMember));
when(otherMember.InstanceId).thenReturn(instanceId);
// the failed argument tells us which instance should be marked as failed
when(otherMember.Alive).thenReturn(true);
aliveMembers.Add(otherMember);
}
foreach (InstanceId instanceId in failed)
{
ClusterMember otherMember = mock(typeof(ClusterMember));
when(otherMember.InstanceId).thenReturn(instanceId);
// the failed argument tells us which instance should be marked as failed
when(otherMember.Alive).thenReturn(false);
failedMembers.Add(otherMember);
}
ClusterMember thisMember = new ClusterMember(me);
aliveMembers.Add(thisMember);
IList <ClusterMember> allMembers = new List <ClusterMember>();
((IList <ClusterMember>)allMembers).AddRange(aliveMembers); // thisMember is in aliveMembers
((IList <ClusterMember>)allMembers).AddRange(failedMembers);
when(members.Members).thenReturn(allMembers);
when(members.AliveMembers).thenReturn(aliveMembers);
return(members);
}
internal virtual void CheckMyStoreIdAndMastersStoreId(StoreId myStoreId, URI masterUri)
{
ClusterMembers clusterMembers = ResolveDatabaseDependency(typeof(ClusterMembers));
InstanceId serverId = HighAvailabilityModeSwitcher.getServerId(masterUri);
IEnumerable <ClusterMember> members = clusterMembers.Members;
ClusterMember master = firstOrNull(filter(hasInstanceId(serverId), members));
if (master == null)
{
throw new System.InvalidOperationException("Cannot find the master among " + members + " with master serverId=" + serverId + " and uri=" + masterUri);
}
StoreId masterStoreId = master.StoreId;
if (!myStoreId.Equals(masterStoreId))
{
throw new MismatchingStoreIdException(myStoreId, master.StoreId);
}
else if (!myStoreId.EqualsByUpgradeId(master.StoreId))
{
throw new BranchedDataException("My store with " + myStoreId + " was updated independently from " + "master's store " + masterStoreId);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldReturnUnavailableStatusWhenShutdown()
public virtual void ShouldReturnUnavailableStatusWhenShutdown()
{
// given
ClusterMember member = _cluster.getCoreMemberById(1);
// when
GraphDatabaseAPI db = member.database();
member.shutdown();
// then
try
{
using (Transaction tx = Db.beginTx())
{
tx.Success();
fail();
}
}
catch (Exception e)
{
assertEquals(Org.Neo4j.Kernel.Api.Exceptions.Status_General.DatabaseUnavailable, statusCodeOf(e));
}
}
/// <summary>
/// Opens the <see cref="DynDnsClient" /> instance enabling it to join
/// the Dynamic DNS Service cluster and to start replicating host/IP address
/// associations.
/// </summary>
/// <param name="router">The <see cref="MsgRouter" /> to be associated with the client (or <c>null</c>).</param>
/// <param name="settings">The <see cref="DynDnsClientSettings" /> to be used.</param>
/// <exception cref="InvalidOperationException">Thrown if the instance is already open.</exception>
/// <remarks>
/// <note>
/// The <see cref="ClusterMemberSettings" />' <see cref="ClusterMemberSettings.Mode" />
/// property will be ignored and the instance aill join the cluster as an
/// <see cref="ClusterMemberMode.Observer" />. The rest of the member settings
/// should be identical to the settings across all cluster instances to avoid
/// strange protocol problems.
/// </note>
/// </remarks>
public void Open(MsgRouter router, DynDnsClientSettings settings)
{
var orgMode = ClusterMemberMode.Unknown;
if (this.isOpen)
{
throw new InvalidOperationException("DynDnsClient is already open.");
}
if (settings.Mode == DynDnsMode.Both)
{
throw new ArgumentException("DynDnsClient does not support [Mode=BOTH].");
}
this.isOpen = true;
this.settings = settings;
// Make sure that the LillTek.Datacenter message types have been
// registered with the LillTek.Messaging subsystem.
LillTek.Datacenter.Global.RegisterMsgTypes();
// Initialize
enabled = settings.Enabled;
if (!enabled)
{
return;
}
if (settings.Cluster != null)
{
orgMode = settings.Cluster.Mode; // $hack(jeff.lill): This is a bit of a hack
settings.Cluster.Mode = ClusterMemberMode.Observer;
}
foreach (var entry in settings.Hosts)
{
Register(entry);
}
try
{
using (TimedLock.Lock(syncLock))
{
if (settings.Mode == DynDnsMode.Cluster)
{
if (router == null)
{
throw new ArgumentException("DynDnsClient requires a valid router when operating with [Mode=CLUSTER].");
}
if (settings.Cluster == null)
{
throw new ArgumentException("Cluster settings must be initialized when [Mode=CLUSTER].");
}
this.router = router;
this.cluster = new ClusterMember(router, settings.Cluster);
foreach (DynDnsHostEntry host in settings.Hosts)
{
hosts[host] = host;
}
this.cluster.Start();
Register(); // Add any pre-existing host registrations to
// the cluster member state
}
else if (settings.Mode == DynDnsMode.Udp)
{
this.udpRegisterTimer = new PolledTimer(settings.UdpRegisterInterval, true);
this.udpRegisterTimer.FireNow();
this.domainRefreshTimer = new PolledTimer(settings.DomainRefreshInterval, true);
this.domainRefreshTimer.FireNow();
this.bkTimer = new GatedTimer(new TimerCallback(OnBkTask), null, settings.BkInterval);
this.socket = new EnhancedSocket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
this.socket.IgnoreUdpConnectionReset = true;
this.socket.Bind(settings.NetworkBinding);
}
}
}
catch
{
Close();
throw;
}
finally
{
if (settings.Cluster != null)
{
settings.Cluster.Mode = orgMode;
}
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public abstract void doWorkOnMember(org.neo4j.causalclustering.discovery.ClusterMember member) throws Exception;
public override abstract void DoWorkOnMember(ClusterMember member);
/// <summary>
/// Releases all resources associated with the instance.
/// </summary>
public void Close()
{
using (TimedLock.Lock(syncLock))
{
if (!isOpen)
{
return;
}
// If we're running in UDP mode, then send a couple deregister messages
// for all host entries to each known name server. This will ensure that
// the DNS updated quickly when servers are shut down gracefully. Note
// that I'm going to send duplicate messages to each server just to be
// on the safe side.
if (settings.Mode == DynDnsMode.Udp)
{
for (int i = 0; i < 2; i++)
{
DynDnsMessage message;
byte[] packet;
foreach (var entry in hosts.Values)
{
message = new DynDnsMessage(DynDnsMessageFlag.OpUnregister, entry);
packet = message.ToArray(settings.SharedKey);
foreach (var nameServer in settings.NameServers)
{
socket.SendTo(packet, nameServer);
}
Thread.Sleep(500);
}
}
}
// Shut down the client.
if (cluster != null)
{
cluster.Stop();
cluster = null;
}
if (bkTimer != null)
{
bkTimer.Dispose();
bkTimer = null;
}
if (socket != null)
{
socket.Close();
socket = null;
}
router = null;
isOpen = false;
}
}
// Initialize cluster with one initial member.
public Cluster(int key, ClusterMember member)
{
Add(key, member);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public void doWorkOnMember(org.neo4j.causalclustering.discovery.ClusterMember core) throws Exception
public override void DoWorkOnMember(ClusterMember core)
{
_startStop.doWorkOnMember(core);
}
