// Token: 0x060002F8 RID: 760 RVA: 0x00011878 File Offset: 0x0000FA78
protected override void RemountInternal(MountFlags mountFlags, DatabaseMountDialOverride mountDialoverride, AmServerName fromServer)
{
AmDbOperationDetailedStatus amDbOperationDetailedStatus = new AmDbOperationDetailedStatus(base.Database);
this.DismountInternal(UnmountFlags.SkipCacheFlush);
this.MountInternal(mountFlags, AmMountFlags.None, mountDialoverride, ref amDbOperationDetailedStatus);
}
// Token: 0x060001AF RID: 431 RVA: 0x0000AA50 File Offset: 0x00008C50
internal void RemountDatabase(Guid mdbGuid, MountFlags mountFlags, DatabaseMountDialOverride mountDialOverride, AmServerName fromServer, AmDbActionCode actionCode)
{
AmTrace.Debug("RemountDatabase ({0},{1},{2},{3},{4}) called", new object[]
{
mdbGuid,
mountFlags,
mountDialOverride,
fromServer,
actionCode
});
ActiveManagerCore.ValidatePamOrStandalone("RemountDatabase");
IADDatabase iaddatabase = this.AdLookup.DatabaseLookup.FindAdObjectByGuidEx(mdbGuid, AdObjectLookupFlags.ReadThrough);
if (iaddatabase == null)
{
throw new AmDatabaseNotFoundException(mdbGuid);
}
AmDbRemountOperation amDbRemountOperation = new AmDbRemountOperation(iaddatabase, actionCode);
amDbRemountOperation.Flags = mountFlags;
amDbRemountOperation.MountDialOverride = mountDialOverride;
amDbRemountOperation.FromServer = fromServer;
amDbRemountOperation.Enqueue();
AmDbCompletionReason amDbCompletionReason = amDbRemountOperation.Wait();
AmTrace.Debug("RemountDatabase({0}) completed (reason={1})", new object[]
{
mdbGuid,
amDbCompletionReason
});
}
// Token: 0x060002F5 RID: 757 RVA: 0x00011688 File Offset: 0x0000F888
protected override void MountInternal(MountFlags storeFlags, AmMountFlags amMountFlags, DatabaseMountDialOverride mountDialoverride, ref AmDbOperationDetailedStatus mountStatus)
{
Exception ex = null;
bool isSuccess = false;
AmServerName activeServer = base.State.ActiveServer;
AmServerName serverToMount = AmServerName.LocalComputerName;
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
try
{
ReplayCrimsonEvents.DirectMountInitiated.LogGeneric(base.PrepareSubactionArgs(new object[]
{
serverToMount,
storeFlags,
false,
amMountFlags
}));
ex = AmHelper.HandleKnownExceptions(delegate(object param0, EventArgs param1)
{
this.ReportStatus(AmDbActionStatus.StoreMountInitiated);
this.WriteStateMountStart(serverToMount);
AmDbAction.MountDatabaseDirect(serverToMount, this.State.LastMountedServer, this.DatabaseGuid, storeFlags, amMountFlags, this.ActionCode);
isSuccess = true;
});
}
finally
{
stopwatch.Stop();
if (isSuccess)
{
base.DbTrace.Debug("Database is now mounted on {0}", new object[]
{
serverToMount
});
SharedDependencies.WritableADHelper.ResetAllowFileRestoreDsFlag(base.DatabaseGuid, activeServer, serverToMount);
ReplayCrimsonEvents.DirectMountSuccess.LogGeneric(base.PrepareSubactionArgs(new object[]
{
serverToMount,
stopwatch.Elapsed
}));
base.WriteStateMountSuccess();
base.ReportStatus(AmDbActionStatus.StoreMountSuccessful);
}
else
{
string text = (ex != null) ? ex.Message : ReplayStrings.UnknownError;
ReplayCrimsonEvents.DirectMountFailed.LogGeneric(base.PrepareSubactionArgs(new object[]
{
serverToMount,
stopwatch.Elapsed,
text
}));
base.WriteStateMountFailed(true);
base.ReportStatus(AmDbActionStatus.StoreMountFailed);
}
}
AmHelper.ThrowDbActionWrapperExceptionIfNecessary(ex);
}
public static UInt64 FromMountFlags(MountFlags value)
{
UInt64 rval;
if (FromMountFlags(value, out rval) == -1)
{
ThrowArgumentException(value);
}
return(rval);
}
private void RequestMount(MountFlags storeMountFlags)
{
AmMountFlags amMountFlags = AmMountFlags.None;
if (this.Force)
{
amMountFlags |= AmMountFlags.MountWithForce;
}
AmRpcClientHelper.MountDatabase(ADObjectWrapperFactory.CreateWrapper(this.DataObject), (int)storeMountFlags, (int)amMountFlags, 0);
}
// Token: 0x060001A8 RID: 424 RVA: 0x0000A59C File Offset: 0x0000879C
internal void MoveDatabase(Guid mdbGuid, MountFlags mountFlags, UnmountFlags dismountFlags, DatabaseMountDialOverride mountDialOverride, AmServerName fromServer, AmServerName targetServer, bool tryOtherHealthyServers, AmBcsSkipFlags skipValidationChecks, AmDbActionCode actionCode, string moveComment, ref AmDatabaseMoveResult databaseMoveResult)
{
AmTrace.Debug("Task: MoveDatabase({0},{1},{2},{3},{4},{5},{6},{7},'{8}') called", new object[]
{
mdbGuid,
mountFlags,
dismountFlags,
mountDialOverride,
fromServer,
targetServer,
tryOtherHealthyServers,
actionCode,
moveComment
});
ActiveManagerCore.ValidatePamOrStandalone("MoveDatabase");
ThirdPartyManager.PreventOperationWhenTPREnabled("MoveDatabase");
IADDatabase iaddatabase = this.AdLookup.DatabaseLookup.FindAdObjectByGuidEx(mdbGuid, AdObjectLookupFlags.ReadThrough);
if (iaddatabase == null)
{
throw new AmDatabaseNotFoundException(mdbGuid);
}
AmDbMoveOperation amDbMoveOperation = new AmDbMoveOperation(iaddatabase, actionCode);
AmDbMoveArguments arguments = amDbMoveOperation.Arguments;
AmDbCompletionReason amDbCompletionReason = AmDbCompletionReason.None;
arguments.MountFlags = mountFlags;
arguments.DismountFlags = dismountFlags;
arguments.MountDialOverride = mountDialOverride;
arguments.SourceServer = fromServer;
arguments.TargetServer = targetServer;
arguments.TryOtherHealthyServers = tryOtherHealthyServers;
arguments.SkipValidationChecks = skipValidationChecks;
arguments.MoveComment = moveComment;
amDbMoveOperation.Arguments = arguments;
amDbMoveOperation.Enqueue();
try
{
amDbCompletionReason = amDbMoveOperation.Wait();
}
finally
{
if (amDbMoveOperation.DetailedStatus != null)
{
databaseMoveResult = amDbMoveOperation.ConvertDetailedStatusToRpcMoveResult(amDbMoveOperation.DetailedStatus);
}
}
AmTrace.Debug("MoveDatabase({0}) completed (reason={1})", new object[]
{
mdbGuid,
amDbCompletionReason
});
}
protected override void RemountInternal(MountFlags mountFlags, DatabaseMountDialOverride mountDialoverride, AmServerName fromServer)
{
Exception exception = null;
base.AttemptDismount(base.State.ActiveServer, UnmountFlags.SkipCacheFlush, true, out exception);
int num = 0;
AmDbNodeAttemptTable dbNodeAttemptTable = AmSystemManager.Instance.DbNodeAttemptTable;
AmAcllReturnStatus amAcllReturnStatus = null;
this.AttemptMountOnServer(base.State.ActiveServer, base.State.ActiveServer, mountFlags, AmMountFlags.None, UnmountFlags.SkipCacheFlush, mountDialoverride, AmBcsSkipFlags.None, false, ref num, ref amAcllReturnStatus, out exception);
base.DbTrace.Debug("AttemptMountOnServer returned AcllStatus: {0}", new object[]
{
amAcllReturnStatus
});
AmHelper.ThrowDbActionWrapperExceptionIfNecessary(exception);
}
} // End Function del_loop
/*public static bool mount(string strDevice, string strMountPoint, string strFsType){
* return mount(strDevice, strMountPoint, strFsType, MountFlags.MS_NOATIME);
* }*/
/*public bool Mount(string strDevice, string strMountPoint, string strFsType, MountFlags mflags){
* return mount(strDevice, strMountPoint, strFsType, mflags, IntPtr.Zero);
* }*/
// http://cboard.cprogramming.com/c-programming/126630-using-sys-mount-h-mounting-usb-thumb-drive.html
// http://stackoverflow.com/questions/10458549/mount-usb-drive-in-linux-with-c
// mount("/dev/loop1", "/mnt/testdisk", "vfat");
public bool Mount(string strDevice, string strMountPoint, string strFsType, MountFlags mflags, string options)
{
// http://linux.die.net/man/2/mount
// MS_RDONLY
// MS_RELATIME (default for Linux >= 2.6.30)
// MS_STRICTATIME (default for Linux < 2.6.30)
if (UnsafeNativeMethods.mount(strDevice, strMountPoint, strFsType, mflags, options) != 0)
{
Mono.Unix.Native.Errno errno = Mono.Unix.Native.Syscall.GetLastError();
throw new Exception(errno.ToString());
}
else
{
return(true);
};
} // End Function mount
protected abstract void MoveInternal(MountFlags mountFlags, UnmountFlags dismountFlags, DatabaseMountDialOverride mountDialoverride, AmServerName fromServer, AmServerName targetServer, bool tryOtherHealthyServers, AmBcsSkipFlags skipValidationChecks, string componentName, ref AmDbOperationDetailedStatus moveStatus);
// Token: 0x06000495 RID: 1173 RVA: 0x00018778 File Offset: 0x00016978
internal static void Mount(Guid mdbGuid, MountFlags flags)
{
bool flag = false;
using (IStoreRpc newStoreControllerInstance = Dependencies.GetNewStoreControllerInstance(null))
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
bool isCheckDbStatus = true;
bool flag2 = false;
for (;;)
{
ReplayCrimsonEvents.MountStoreRpcInitiated.Log <Guid, MountFlags>(mdbGuid, flags);
Exception ex = null;
try
{
try
{
newStoreControllerInstance.MountDatabase(Guid.Empty, mdbGuid, (int)flags);
AmTrace.Info("rpcAdmin.MountDatabase({0}) successful.", new object[]
{
mdbGuid
});
isCheckDbStatus = false;
flag2 = true;
break;
}
catch (MapiExceptionMountInProgress mapiExceptionMountInProgress)
{
ex = mapiExceptionMountInProgress;
AmTrace.Error("rpcAdmin.MountDatabase({0}) encountered {1}.", new object[]
{
mdbGuid,
mapiExceptionMountInProgress.Message
});
if (!flag)
{
ReplayCrimsonEvents.MountDelayedUntilPreviousOperationIsComplete.Log <Guid, string>(mdbGuid, mapiExceptionMountInProgress.Message);
flag = true;
}
if (stopwatch.Elapsed > AmStoreHelper.defaultMapiConflictTimeout)
{
throw;
}
if (AmHelper.SleepUntilShutdown(AmStoreHelper.defaultMapiConflictRetryInterval))
{
AmTrace.Debug("shutdown requested - hence not retrying mount for database {0}", new object[]
{
mdbGuid
});
throw;
}
}
catch (MapiPermanentException ex2)
{
ex = ex2;
throw;
}
catch (MapiRetryableException ex3)
{
ex = ex3;
throw;
}
continue;
}
finally
{
if (flag2)
{
ReplayCrimsonEvents.MountStoreRpcSucceeded.Log <Guid>(mdbGuid);
}
else if (ex == null || !(ex is MapiExceptionMountInProgress))
{
ReplayCrimsonEvents.MountStoreRpcFailed.Log <Guid, string, Exception>(mdbGuid, (ex != null) ? ex.Message : null, ex);
}
AmStoreHelper.UpdateIsMountedCounterNoDatabaseCache(mdbGuid, null, flag2, isCheckDbStatus);
}
break;
}
}
}
private static extern int ToMountFlags (UInt64 value, out MountFlags rval);
public static bool TryFromMountFlags (MountFlags value, out UInt64 rval)
{
return FromMountFlags (value, out rval) == 0;
}
internal void Remount(MountFlags mountFlags, DatabaseMountDialOverride mountDialoverride, AmServerName fromServer)
{
Exception ex = null;
bool flag = true;
AmServerName amServerName = null;
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
try
{
using (AmDatabaseOperationLock.Lock(this.DatabaseGuid, AmDbLockReason.Remount, null))
{
ex = AmHelper.HandleKnownExceptions(delegate(object param0, EventArgs param1)
{
ReplayCrimsonEvents.ToplevelRemountInitiated.LogGeneric(this.PrepareStartupArgs(new object[]
{
mountFlags,
mountDialoverride,
fromServer
}));
if (!this.State.IsEntryExist)
{
this.DbTrace.Error("Database was never mounted. Remount is applicable only if it was mounted at least once", new object[0]);
throw new AmDatabaseNeverMountedException();
}
if (this.State.IsAdminDismounted)
{
this.DbTrace.Error("Skipping remount action since the database was admin dismounted", new object[0]);
throw new AmDbRemountSkippedSinceDatabaseWasAdminDismounted(this.DatabaseName);
}
if (!AmServerName.IsEqual(this.State.ActiveServer, fromServer))
{
this.DbTrace.Error("Skipping remount action since database master had changed", new object[0]);
throw new AmDbRemountSkippedSinceMasterChanged(this.DatabaseName, this.State.ActiveServer.Fqdn, fromServer.NetbiosName);
}
this.EnsureAutomaticActionIsAllowed();
this.RemountInternal(mountFlags, mountDialoverride, fromServer);
});
this.WriteStateClearIfInProgressStatus(true);
flag = false;
}
}
catch (AmDbLockConflictException ex2)
{
ex = ex2;
}
finally
{
stopwatch.Stop();
if (flag || ex != null)
{
string text = (ex != null) ? ex.Message : ReplayStrings.UnknownError;
ReplayCrimsonEvents.ToplevelRemountFailed.LogGeneric(this.PrepareCompletionArgs(new object[]
{
stopwatch.Elapsed,
text
}));
ReplayEventLogConstants.Tuple_AmDatabaseMountFailed.LogEvent(null, new object[]
{
this.DatabaseName,
amServerName,
text
});
}
else
{
ReplayCrimsonEvents.ToplevelRemountSuccess.LogGeneric(this.PrepareCompletionArgs(new object[]
{
stopwatch.Elapsed
}));
ReplayEventLogConstants.Tuple_AmDatabaseMounted.LogEvent(null, new object[]
{
this.DatabaseName,
amServerName
});
}
}
if (ex != null)
{
throw ex;
}
}
internal void Mount(MountFlags storeFlags, AmMountFlags amMountFlags, DatabaseMountDialOverride mountDialoverride, ref AmDbOperationDetailedStatus mountStatus)
{
mountStatus = new AmDbOperationDetailedStatus(this.Database);
Exception ex = null;
bool flag = true;
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
AmDbOperationDetailedStatus tempStatus = mountStatus;
try
{
using (AmDatabaseOperationLock.Lock(this.DatabaseGuid, AmDbLockReason.Mount, null))
{
ex = AmHelper.HandleKnownExceptions(delegate(object param0, EventArgs param1)
{
ReplayCrimsonEvents.ToplevelMountInitiated.LogGeneric(this.PrepareStartupArgs(new object[]
{
storeFlags,
mountDialoverride
}));
this.EnsureAutomaticActionIsAllowed();
this.ClearFailureAttemptIfAdminAction(this.DatabaseGuid);
if (!this.State.IsEntryExist)
{
this.DbTrace.Info("Mounting database for the first time!", new object[0]);
}
this.MountInternal(storeFlags, amMountFlags, mountDialoverride, ref tempStatus);
});
mountStatus = tempStatus;
this.WriteStateClearIfInProgressStatus(true);
flag = false;
}
}
catch (AmDbLockConflictException ex2)
{
ex = ex2;
}
finally
{
stopwatch.Stop();
if (flag || ex != null)
{
string text = (ex != null) ? ex.Message : ReplayStrings.UnknownError;
ReplayCrimsonEvents.ToplevelMountFailed.LogGeneric(this.PrepareCompletionArgs(new object[]
{
stopwatch.Elapsed,
text
}));
ReplayEventLogConstants.Tuple_AmDatabaseMountFailed.LogEvent(null, new object[]
{
this.DatabaseName,
this.State.ActiveServer,
text
});
}
else
{
ReplayCrimsonEvents.ToplevelMountSuccess.LogGeneric(this.PrepareCompletionArgs(new object[]
{
stopwatch.Elapsed
}));
ReplayEventLogConstants.Tuple_AmDatabaseMounted.LogEvent(null, new object[]
{
this.DatabaseName,
this.State.ActiveServer
});
}
}
if (ex != null)
{
throw ex;
}
}
protected override void MountInternal(MountFlags storeMountFlags, AmMountFlags amMountFlags, DatabaseMountDialOverride mountDialOverride, ref AmDbOperationDetailedStatus mountStatus)
{
Exception ex = null;
int natSkippedServersCount = 0;
int num = 0;
bool flag = true;
if (ThirdPartyManager.IsThirdPartyReplicationEnabled)
{
flag = false;
}
if (base.ActionCode.IsAdminOperation)
{
if (base.State.IsActiveServerValid)
{
flag = false;
}
else
{
AmTrace.Debug("Mount issued for the first time on this database. We will try all the available servers. (db={0})", new object[]
{
base.DatabaseName
});
}
}
AmServerName amServerName = base.State.ActiveServer;
if (AmServerName.IsNullOrEmpty(amServerName))
{
amServerName = new AmServerName(base.Database.Server.Name);
}
AmBcsSkipFlags skipValidationChecks = AmBcsSkipFlags.SkipAll;
if (flag)
{
skipValidationChecks = AmBcsSkipFlags.None;
}
IBestCopySelector bestCopySelector = this.ConstructBestCopySelector(flag, skipValidationChecks, null, amServerName, amServerName, mountDialOverride, null);
AmDbNodeAttemptTable dbNodeAttemptTable = AmSystemManager.Instance.DbNodeAttemptTable;
if (base.ActionCode.IsAdminOperation)
{
dbNodeAttemptTable.ClearFailedTime(base.DatabaseGuid);
}
AmServerName sourceServer = amServerName;
AmAcllReturnStatus amAcllReturnStatus = null;
AmServerName amServerName2 = bestCopySelector.FindNextBestCopy();
while (amServerName2 != null)
{
num++;
base.DbTrace.Debug("Attempting mount on server {0}", new object[]
{
amServerName2
});
this.AttemptMountOnServer(amServerName2, sourceServer, storeMountFlags, amMountFlags, UnmountFlags.SkipCacheFlush, mountDialOverride, AmBcsSkipFlags.None, flag, ref natSkippedServersCount, ref amAcllReturnStatus, out ex);
base.DbTrace.Debug("AttemptMountOnServer returned AcllStatus: {0}", new object[]
{
amAcllReturnStatus
});
sourceServer = base.State.ActiveServer;
if (ex == null)
{
break;
}
bestCopySelector.ErrorLogger.ReportServerFailure(amServerName2, "CopyHasBeenTriedCheck", ex.Message);
if (ex is AmRoleChangedWhileOperationIsInProgressException || ex is AmMountTimeoutException)
{
break;
}
amServerName2 = bestCopySelector.FindNextBestCopy();
base.CurrentAttemptNumber++;
}
this.CheckActionResultsAndUpdateAdProperties(amServerName, null, bestCopySelector, ex, num, natSkippedServersCount);
}
private void RunMountDatabaseDirect(AmServerName serverToMount, MountFlags storeMountFlags, AmMountFlags amMountFlags, bool fLossyMountEnabled, TimeSpan mountTimeout, ref bool isMasterChanged)
{
bool flag = false;
bool flag2 = false;
isMasterChanged = false;
AmDbNodeAttemptTable dbNodeAttemptTable = AmSystemManager.Instance.DbNodeAttemptTable;
AmServerName activeServer = base.State.ActiveServer;
try
{
isMasterChanged = this.UpdateMaster(serverToMount, false);
base.ReportStatus(AmDbActionStatus.StoreMountInitiated);
if (fLossyMountEnabled)
{
storeMountFlags |= MountFlags.AllowDatabasePatch;
}
ExTraceGlobals.FaultInjectionTracer.TraceTest(2229677373U);
try
{
InvokeWithTimeout.Invoke(delegate()
{
AmDbAction.MountDatabaseDirect(serverToMount, this.State.LastMountedServer, this.DatabaseGuid, storeMountFlags, amMountFlags, this.ActionCode);
ExTraceGlobals.FaultInjectionTracer.TraceTest(2441489725U);
}, mountTimeout);
}
catch (TimeoutException ex)
{
base.DbTrace.Error("Mount timeout on {0}: {1}", new object[]
{
base.DatabaseName,
ex
});
AmMountTimeoutException ex2 = new AmMountTimeoutException(base.DatabaseName, serverToMount.NetbiosName, (int)mountTimeout.TotalSeconds, ex);
this.HandleMountTimeout(serverToMount, ex2);
throw ex2;
}
flag = true;
dbNodeAttemptTable.ClearFailedTime(base.DatabaseGuid);
try
{
base.WriteStateMountSuccess();
}
catch (AmRoleChangedWhileOperationIsInProgressException ex3)
{
base.DbTrace.Warning("Mount AmRoleChanged exception (error={0})", new object[]
{
ex3
});
}
base.ReportStatus(AmDbActionStatus.StoreMountSuccessful);
}
catch (TransientException ex4)
{
base.DbTrace.Error("Mount transient exception (error={0})", new object[]
{
ex4
});
flag2 = true;
throw;
}
catch (AmReplayServiceDownException ex5)
{
base.DbTrace.Error("Mount transient RPC exception (error={0})", new object[]
{
ex5
});
flag2 = true;
throw;
}
finally
{
if (flag)
{
SharedDependencies.WritableADHelper.ResetAllowFileRestoreDsFlag(base.DatabaseGuid, activeServer, serverToMount);
}
else
{
base.WriteStateMountFailed(true);
if (base.ActionCode.IsAutomaticFailureItem && !flag2)
{
dbNodeAttemptTable.MarkFailedTime(base.DatabaseGuid, serverToMount, base.ActionCode);
}
base.ReportStatus(AmDbActionStatus.StoreMountFailed);
}
if (isMasterChanged && AmSystemManager.Instance.Config.IsPAM)
{
this.SendReplicaNotifications();
}
}
}
private bool AttemptMountOnServer(AmServerName serverToMount, AmServerName sourceServer, MountFlags storeMountFlags, AmMountFlags amMountFlags, UnmountFlags dismountFlags, DatabaseMountDialOverride mountDialoverride, AmBcsSkipFlags skipValidationChecks, bool tryOtherHealthyServers, ref int natSkippedServersCount, ref AmAcllReturnStatus acllStatus, out Exception lastException)
{
bool flag = true;
bool fLossyMountEnabled = false;
bool isSuccess = false;
bool isAcllSuccess = false;
bool isMasterServerChanged = false;
lastException = null;
bool isSuccess2;
try
{
acllStatus = new AmAcllReturnStatus();
AmDbNodeAttemptTable dbNodeAttemptTable = AmSystemManager.Instance.DbNodeAttemptTable;
if (!base.ActionCode.IsAdminOperation && base.Config.IsIgnoreServerDebugOptionEnabled(serverToMount))
{
ReplayCrimsonEvents.OperationNotPerformedDueToDebugOption.Log <string, string, string>(serverToMount.Fqdn, AmDebugOptions.IgnoreServerFromAutomaticActions.ToString(), "Mount database");
throw new AmDbOperationException("Mount not applicable for a server when debug options are enabled");
}
bool flag2 = this.IsAcllRequired(serverToMount, sourceServer);
if (dbNodeAttemptTable.IsOkayForAction(base.Database, serverToMount, base.ActionCode))
{
if (!flag2)
{
acllStatus.NoLoss = true;
acllStatus.MountAllowed = true;
}
else
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
try
{
ReplayCrimsonEvents.AcllInitiated.LogGeneric(base.PrepareSubactionArgs(new object[]
{
serverToMount,
sourceServer
}));
AmAcllReturnStatus tempAcllStatus = null;
lastException = AmHelper.HandleKnownExceptions(delegate(object param0, EventArgs param1)
{
this.RunAttemptCopyLastLogsOnServer(serverToMount, sourceServer, mountDialoverride, skipValidationChecks, 1, 15000, 15000, 15000, out fLossyMountEnabled, ref tempAcllStatus);
isAcllSuccess = true;
});
acllStatus = tempAcllStatus;
}
finally
{
stopwatch.Stop();
if (isAcllSuccess)
{
ReplayCrimsonEvents.AcllSuccess2.LogGeneric(base.PrepareSubactionArgs(new object[]
{
serverToMount,
fLossyMountEnabled,
stopwatch.Elapsed
}));
}
else
{
ReplayCrimsonEvents.AcllFailed.LogGeneric(base.PrepareSubactionArgs(new object[]
{
serverToMount,
stopwatch.Elapsed,
(lastException != null) ? lastException.Message : ReplayStrings.UnknownError
}));
}
}
if (lastException == null)
{
if (base.State.IsAdminDismounted && !base.ActionCode.IsAdminMountOperation)
{
AmTrace.Debug("Skipping mount for database '{0}' on server '{1}' since it was admin dismounted.", new object[]
{
base.DatabaseName,
serverToMount
});
if (this.UpdateMaster(serverToMount, true))
{
this.SendReplicaNotifications();
isMasterServerChanged = true;
}
isSuccess = true;
flag = false;
}
}
else
{
flag = false;
}
}
if (!flag)
{
goto IL_45C;
}
isSuccess = false;
lastException = null;
Stopwatch stopwatch2 = new Stopwatch();
stopwatch2.Start();
try
{
ReplayCrimsonEvents.DirectMountInitiated.LogGeneric(base.PrepareSubactionArgs(new object[]
{
serverToMount,
storeMountFlags,
fLossyMountEnabled,
amMountFlags
}));
lastException = AmHelper.HandleKnownExceptions(delegate(object param0, EventArgs param1)
{
TimeSpan mountTimeout = this.DetermineMountTimeout(skipValidationChecks);
this.RunMountDatabaseDirect(serverToMount, storeMountFlags, amMountFlags, fLossyMountEnabled, mountTimeout, ref isMasterServerChanged);
isSuccess = true;
});
goto IL_45C;
}
finally
{
stopwatch2.Stop();
if (isSuccess)
{
ReplayCrimsonEvents.DirectMountSuccess.LogGeneric(base.PrepareSubactionArgs(new object[]
{
serverToMount,
stopwatch2.Elapsed
}));
}
else
{
string text = (lastException != null) ? lastException.Message : ReplayStrings.UnknownError;
ReplayCrimsonEvents.DirectMountFailed.LogGeneric(base.PrepareSubactionArgs(new object[]
{
serverToMount,
stopwatch2.Elapsed,
text
}));
}
}
}
natSkippedServersCount++;
AmTrace.Debug("Mount for database '{0}' skipped server '{1}' since a recent mount operation on this node failed.", new object[]
{
base.DatabaseName,
serverToMount
});
lastException = new AmDbOperationAttempedTooSoonException(base.DatabaseName);
ReplayCrimsonEvents.MountServerSkipped.LogGeneric(base.PrepareSubactionArgs(new object[]
{
serverToMount,
lastException.Message
}));
isSuccess = false;
IL_45C:
isSuccess2 = isSuccess;
}
finally
{
if (!isMasterServerChanged)
{
AmTrace.Error("The active server for database '{0}' has not been changed, so we need to rollback the database state tracker information.", new object[]
{
base.DatabaseName
});
AmDatabaseStateTracker databaseStateTracker = AmSystemManager.Instance.DatabaseStateTracker;
if (databaseStateTracker != null)
{
databaseStateTracker.UpdateActive(base.DatabaseGuid, sourceServer);
}
}
}
return(isSuccess2);
}
protected override void MoveInternal(MountFlags storeMountFlags, UnmountFlags dismountFlags, DatabaseMountDialOverride mountDialoverride, AmServerName fromServer, AmServerName targetServer, bool tryOtherHealthyServers, AmBcsSkipFlags skipValidationChecks, string componentName, ref AmDbOperationDetailedStatus moveStatus)
{
AmDbNodeAttemptTable dbNodeAttemptTable = AmSystemManager.Instance.DbNodeAttemptTable;
IBestCopySelector bestCopySelector = null;
Exception ex = null;
bool flag = false;
int num = 0;
int natSkippedServersCount = 0;
if (!base.State.IsEntryExist)
{
base.DbTrace.Error("Database was never mounted. Move is applicable only if it was mounted at least once", new object[0]);
throw new AmDatabaseNeverMountedException();
}
if (base.State.IsAdminDismounted)
{
AmTrace.Diagnostic("Moving a dismounted database {0}. The database will be moved, but won't be mounted", new object[]
{
base.DatabaseName
});
}
moveStatus.InitialDbState = base.State.Copy();
AmServerName activeServer = base.State.ActiveServer;
AmAcllReturnStatus amAcllReturnStatus = null;
bool flag2 = true;
try
{
this.CheckIfMoveApplicableForDatabase(base.State.ActiveServer, fromServer, base.ActionCode);
bestCopySelector = this.ConstructBestCopySelector(tryOtherHealthyServers, skipValidationChecks, null, activeServer, targetServer, mountDialoverride, componentName);
if (base.ActionCode.IsAutomaticShutdownSwitchover)
{
base.AttemptDismount(base.State.ActiveServer, dismountFlags, true, out ex);
flag = true;
}
AmServerName amServerName = bestCopySelector.FindNextBestCopy();
while (amServerName != null)
{
num++;
if (!flag)
{
base.AttemptDismount(activeServer, dismountFlags, true, out ex);
flag = true;
}
AmMountFlags amMountFlags = AmMountFlags.None;
if (BitMasker.IsOn((int)skipValidationChecks, 4))
{
amMountFlags = AmMountFlags.MoveWithSkipHealth;
}
this.AttemptMountOnServer(amServerName, base.State.ActiveServer, storeMountFlags, amMountFlags, dismountFlags, mountDialoverride, skipValidationChecks, tryOtherHealthyServers, ref natSkippedServersCount, ref amAcllReturnStatus, out ex);
base.DbTrace.Debug("AttemptMountOnServer returned AcllStatus: {0}", new object[]
{
amAcllReturnStatus
});
moveStatus.AddSubstatus(new AmDbOperationSubStatus(amServerName, amAcllReturnStatus, ex));
if (ex == null)
{
flag2 = false;
break;
}
bestCopySelector.ErrorLogger.ReportServerFailure(amServerName, "CopyHasBeenTriedCheck", ex.Message);
if (ex is AmRoleChangedWhileOperationIsInProgressException)
{
flag2 = false;
break;
}
if (ex is AmMountTimeoutException)
{
flag2 = false;
break;
}
amServerName = bestCopySelector.FindNextBestCopy();
base.CurrentAttemptNumber++;
}
}
finally
{
moveStatus.FinalDbState = base.State.Copy();
}
if (flag2)
{
MountStatus storeDatabaseMountStatus = AmStoreHelper.GetStoreDatabaseMountStatus(base.State.ActiveServer, base.Database.Guid);
if (storeDatabaseMountStatus != base.State.MountStatus)
{
ReplayCrimsonEvents.MismatchErrorAfterMove.Log <string, Guid, AmServerName, MountStatus, MountStatus>(base.Database.Name, base.Database.Guid, base.State.ActiveServer, base.State.MountStatus, storeDatabaseMountStatus);
if (storeDatabaseMountStatus == MountStatus.Dismounted)
{
base.State.MountStatus = MountStatus.Dismounted;
base.WriteState();
}
}
}
this.CheckActionResultsAndUpdateAdProperties(activeServer, targetServer, bestCopySelector, ex, num, natSkippedServersCount);
}
private static int ToMountFlags (UInt64 value, out MountFlags rval)
{
throw new System.NotImplementedException();
}
private static int FromMountFlags (MountFlags value, out UInt64 rval)
{
throw new System.NotImplementedException();
}
protected abstract void RemountInternal(MountFlags mountFlags, DatabaseMountDialOverride mountDialoverride, AmServerName fromServer);
internal static void MountDatabaseDirect(AmServerName serverName, AmServerName lastMountedServerName, Guid dbGuid, MountFlags storeFlags, AmMountFlags amFlags, AmDbActionCode actionCode)
{
AmFaultInject.GenerateMapiExceptionIfRequired(dbGuid, serverName);
AmMountArg mountArg = new AmMountArg((int)storeFlags, (int)amFlags, lastMountedServerName.Fqdn, (int)actionCode);
Dependencies.AmRpcClientWrapper.MountDatabaseDirectEx(serverName.Fqdn, dbGuid, mountArg);
}
private static extern int FromMountFlags(MountFlags value, out UInt64 rval);
internal void Move(MountFlags mountFlags, UnmountFlags dismountFlags, DatabaseMountDialOverride mountDialoverride, AmServerName fromServer, AmServerName targetServer, bool tryOtherHealthyServers, AmBcsSkipFlags skipValidationChecks, string moveComment, string componentName, ref AmDbOperationDetailedStatus moveStatus)
{
moveStatus = new AmDbOperationDetailedStatus(this.Database);
Exception ex = null;
bool flag = true;
AmServerName initialSourceServer = null;
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
string initialActive = string.Empty;
AmDbOperationDetailedStatus tempStatus = moveStatus;
try
{
using (AmDatabaseOperationLock.Lock(this.DatabaseGuid, AmDbLockReason.Move, null))
{
ex = AmHelper.HandleKnownExceptions(delegate(object param0, EventArgs param1)
{
initialActive = this.GetSafeActiveServer();
ReplayCrimsonEvents.ToplevelMoveInitiated.LogGeneric(this.PrepareStartupArgs(new object[]
{
mountFlags,
dismountFlags,
mountDialoverride,
AmServerName.IsNullOrEmpty(fromServer) ? initialActive : fromServer.Fqdn,
targetServer,
tryOtherHealthyServers,
skipValidationChecks,
moveComment,
componentName
}));
initialSourceServer = this.State.ActiveServer;
this.EnsureAutomaticActionIsAllowed();
this.ClearFailureAttemptIfAdminAction(this.DatabaseGuid);
this.MoveInternal(mountFlags, dismountFlags, mountDialoverride, fromServer, targetServer, tryOtherHealthyServers, skipValidationChecks, componentName, ref tempStatus);
});
this.WriteStateClearIfInProgressStatus(true);
flag = false;
}
}
catch (AmDbLockConflictException ex2)
{
ex = ex2;
}
finally
{
stopwatch.Stop();
moveStatus = tempStatus;
if (flag || ex != null)
{
string text = (ex != null) ? ex.Message : ReplayStrings.UnknownError;
ReplayCrimsonEvents.ToplevelMoveFailed.LogGeneric(this.PrepareCompletionArgs(new object[]
{
initialActive,
stopwatch.Elapsed,
text,
moveComment
}));
if (AmServerName.IsNullOrEmpty(targetServer))
{
ReplayEventLogConstants.Tuple_AmDatabaseMoveUnspecifiedServerFailed.LogEvent(null, new object[]
{
this.DatabaseName,
initialSourceServer,
text,
moveComment
});
}
else
{
ReplayEventLogConstants.Tuple_AmDatabaseMoveFailed.LogEvent(null, new object[]
{
this.DatabaseName,
initialActive,
targetServer,
text,
moveComment
});
}
}
else
{
ReplayCrimsonEvents.ToplevelMoveSuccess.LogGeneric(this.PrepareCompletionArgs(new object[]
{
initialActive,
stopwatch.Elapsed,
moveComment
}));
ReplayEventLogConstants.Tuple_AmDatabaseMoved.LogEvent(null, new object[]
{
this.DatabaseName,
initialActive,
moveStatus.FinalDbState.ActiveServer,
moveComment
});
}
}
if (ex != null)
{
throw ex;
}
}
public static bool TryFromMountFlags(MountFlags value, out UInt64 rval)
{
return(FromMountFlags(value, out rval) == 0);
}
private static extern int FromMountFlags (MountFlags value, out UInt64 rval);
// http://cboard.cprogramming.com/c-programming/126630-using-sys-mount-h-mounting-usb-thumb-drive.html
// http://stackoverflow.com/questions/10458549/mount-usb-drive-in-linux-with-c
// mount("/dev/loop1", "/mnt/testdisk", "vfat");
public static bool mount(string strDevice, string strMountPoint, string strFsType, MountFlags mflags, IntPtr options)
{
// http://linux.die.net/man/2/mount
// MS_RDONLY
// MS_RELATIME (default for Linux >= 2.6.30)
// MS_STRICTATIME (default for Linux < 2.6.30)
if (UnsafeNativeMethods.mount(strDevice, strMountPoint, strFsType, mflags, options) != 0)
{
Mono.Unix.Native.Errno errno = Mono.Unix.Native.Syscall.GetLastError();
if (errno == Mono.Unix.Native.Errno.EBUSY)
{
Console.WriteLine("Mountpoint busy");
}
else
{
Console.WriteLine("Mount error: " + Mono.Unix.Native.Syscall.strerror(errno));
}
return(false);
}
else
{
Console.WriteLine("Successfully mounted device !");
}
return(true);;
} // End Function mount
public static UInt64 FromMountFlags (MountFlags value)
{
UInt64 rval;
if (FromMountFlags (value, out rval) == -1)
ThrowArgumentException (value);
return rval;
}
private static int FromMountFlags(MountFlags value, out UInt64 rval)
{
throw new System.NotImplementedException();
}
public static bool TryToMountFlags (UInt64 value, out MountFlags rval)
{
return ToMountFlags (value, out rval) == 0;
}
protected abstract void MountInternal(MountFlags storeFlags, AmMountFlags amMountFlags, DatabaseMountDialOverride mountDialoverride, ref AmDbOperationDetailedStatus mountStatus);
// Token: 0x060001AA RID: 426 RVA: 0x0000A74C File Offset: 0x0000894C
internal List <AmDatabaseMoveResult> ServerMoveAllDatabases(AmServerName sourceServer, AmServerName targetServer, MountFlags mountFlags, UnmountFlags dismountFlags, DatabaseMountDialOverride mountDialOverride, bool tryOtherHealthyServers, AmBcsSkipFlags skipValidationChecks, AmDbActionCode actionCode, string moveComment, string componentName)
{
AmTrace.Debug("ServerMoveAllDatabases() called: sourceServer='{0}', targetServer='{1}', mountFlags='{2}', dismountFlags='{3}', mountDialOverride='{4}', tryOtherHealthyServers='{5}', skipValidationChecks='{6}', actionCode='{7}', MoveComment='{8}' Component='{9}'", new object[]
{
sourceServer,
targetServer,
mountFlags,
dismountFlags,
mountDialOverride,
tryOtherHealthyServers,
skipValidationChecks,
actionCode,
moveComment,
componentName
});
ActiveManagerCore.ValidatePamOrStandalone("ServerMoveAllDatabases");
ThirdPartyManager.PreventOperationWhenTPREnabled("ServerMoveAllDatabases");
AmDbMoveArguments amDbMoveArguments = new AmDbMoveArguments(actionCode);
amDbMoveArguments.SourceServer = sourceServer;
amDbMoveArguments.TargetServer = targetServer;
amDbMoveArguments.MountFlags = mountFlags;
amDbMoveArguments.DismountFlags = dismountFlags;
amDbMoveArguments.MountDialOverride = mountDialOverride;
amDbMoveArguments.TryOtherHealthyServers = tryOtherHealthyServers;
amDbMoveArguments.SkipValidationChecks = skipValidationChecks;
amDbMoveArguments.MoveComment = moveComment;
amDbMoveArguments.ComponentName = componentName;
if (string.IsNullOrEmpty(sourceServer.Fqdn))
{
return(MoveBackToServer.Move(amDbMoveArguments));
}
AmEvtMoveAllDatabasesBase amEvtMoveAllDatabasesBase;
if (actionCode.IsAutomaticManagedAvailabilityFailover)
{
amEvtMoveAllDatabasesBase = new AmEvtMoveAllDatabasesOnComponentRequest(sourceServer);
}
else
{
amEvtMoveAllDatabasesBase = new AmEvtMoveAllDatabasesOnAdminRequest(sourceServer);
}
amEvtMoveAllDatabasesBase.MoveArgs = amDbMoveArguments;
amEvtMoveAllDatabasesBase.Notify();
amEvtMoveAllDatabasesBase.WaitForSwitchoverComplete();
AmTrace.Debug("ServerMoveAllDatabases({0}) completed", new object[]
{
sourceServer
});
return(amEvtMoveAllDatabasesBase.GetMoveResultsForOperationsRun());
}
//int mount(const char *source, const char *target, const char *filesystemtype, ulong mountflags, const void *data);
public static int mount(string source, string target, string filesystemtype, MountFlags mountflags, System.IntPtr data)
{
System.UIntPtr p = new System.UIntPtr((ulong)mountflags);
return(mount(source, target, filesystemtype, p, data));
} // End Function mount
// Token: 0x060001B1 RID: 433 RVA: 0x0000AD64 File Offset: 0x00008F64
internal void MountDatabaseDirect(Guid mdbGuid, MountFlags storeFlags, AmMountFlags amMountFlags, AmDbActionCode actionCode)
{
AmTrace.Debug("MountDatabaseDirect called. (Guid={0}, StoreFlags={1}, AmMountFlags={2} ActionCode={3})", new object[]
{
mdbGuid,
storeFlags,
amMountFlags,
actionCode
});
AmConfig config = AmSystemManager.Instance.Config;
if (!config.IsUnknown)
{
bool flag = false;
LogStreamResetOnMount logReset = null;
MountDirectPerformanceTracker mountPerf = new MountDirectPerformanceTracker(mdbGuid);
ReplicaInstanceContext replicaInstanceContext = null;
try
{
int actualMountFlags = (int)storeFlags;
IADDatabase db = this.AdLookup.DatabaseLookup.FindAdObjectByGuidEx(mdbGuid, AdObjectLookupFlags.None);
if (db == null)
{
throw new AmDatabaseNotFoundException(mdbGuid);
}
if (AmSystemManager.Instance.IsSystemShutdownInProgress)
{
ReplayCrimsonEvents.MountRejectedSinceSystemShutdownInProgress.Log <string, Guid, ExDateTime?>(db.Name, mdbGuid, AmSystemManager.Instance.SystemShutdownStartTime);
throw new AmInvalidConfiguration(string.Empty);
}
ExTraceGlobals.FaultInjectionTracer.TraceTest(2198220093U);
mountPerf.RunTimedOperation(MountDatabaseDirectOperation.AmPreMountCallback, delegate
{
this.m_replicaInstanceManager.AmPreMountCallback(mdbGuid, ref actualMountFlags, amMountFlags, mountPerf, out logReset, out replicaInstanceContext);
});
mountPerf.RunTimedOperation(MountDatabaseDirectOperation.RegistryReplicatorCopy, delegate
{
this.m_registryMonitor.PreMountCopy(mdbGuid, db.IsPublicFolderDatabase);
});
if (replicaInstanceContext != null)
{
replicaInstanceContext.IsReplayDatabaseDismountPending = false;
}
ExTraceGlobals.FaultInjectionTracer.TraceTest(2166762813U);
try
{
mountPerf.RunTimedOperation(MountDatabaseDirectOperation.StoreMount, delegate
{
AmStoreHelper.Mount(mdbGuid, (MountFlags)actualMountFlags);
});
}
catch (MapiExceptionDismountInProgress mapiExceptionDismountInProgress)
{
AmTrace.Error("AmStoreHelper.Mount encountered exception {0}", new object[]
{
mapiExceptionDismountInProgress
});
mountPerf.IsDismountInProgress = true;
throw;
}
((ReplicaInstanceManager)this.m_replicaInstanceManager).ClearLossyMountRecord(mdbGuid);
((ReplicaInstanceManager)this.m_replicaInstanceManager).ClearLastAcllRunWithSkipHealthChecksRecord(mdbGuid);
AmTrace.Debug("MountDatabaseDirect initiating UpdateReplicationContentIndexing() asynchronously for DB '{0}'.", new object[]
{
mdbGuid
});
ThreadPool.QueueUserWorkItem(delegate(object obj)
{
Exception ex = ReplicaInstance.UpdateReplicationContentIndexing();
if (ex != null)
{
AmTrace.Error("MountDatabaseDirect background call of UpdateReplicationContentIndexing() failed for DB '{0}'. Exception: {1}", new object[]
{
(Guid)obj,
ex
});
}
}, mdbGuid);
this.DetermineWorkerProcessId(mdbGuid);
this.m_registryMonitor.PostMountCopy();
flag = true;
return;
}
finally
{
if (replicaInstanceContext != null)
{
replicaInstanceContext.BestEffortDismountReplayDatabase();
}
if (logReset != null && logReset.ResetPending)
{
if (flag)
{
mountPerf.RunTimedOperation(MountDatabaseDirectOperation.ConfirmLogReset, delegate
{
logReset.ConfirmLogReset();
});
Dependencies.ConfigurationUpdater.NotifyChangedReplayConfiguration(mdbGuid, false, true, true, true, ReplayConfigChangeHints.AmPreMountCallbackLogStreamReset, -1);
}
else
{
logReset.CancelLogReset();
}
}
mountPerf.LogEvent();
}
}
AmTrace.Error("MountDatabaseDirect: AmConfig is invalid!", new object[0]);
throw new AmInvalidConfiguration(config.LastError);
}
private static extern int ToMountFlags(UInt64 value, out MountFlags rval);
private static int ToMountFlags(UInt64 value, out MountFlags rval)
{
throw new System.NotImplementedException();
}
public static bool TryToMountFlags(UInt64 value, out MountFlags rval)
{
return(ToMountFlags(value, out rval) == 0);
}
