public bool ReplicateAssociation(IAssociationAdaptor masterAdaptor, params MailboxAssociation[] associations)
{
ArgumentValidator.ThrowIfNull("associations", associations);
ArgumentValidator.ThrowIfZeroOrNegative("associations.Length", associations.Length);
PriorityReplicator.Tracer.TraceDebug((long)this.GetHashCode(), "PriorityReplicator::ReplicateAssociations");
bool flag = true;
MailboxAssociation priorityAssociation = this.GetAssociationWithPriority(masterAdaptor, associations);
if (priorityAssociation != null)
{
PriorityReplicator.Tracer.TraceDebug((long)this.GetHashCode(), "PriorityReplicator::ReplicateAssociations. Found priority association");
flag &= this.priorityReplicator.ReplicateAssociation(masterAdaptor, new MailboxAssociation[]
{
priorityAssociation
});
MailboxAssociation[] array = (from association in associations
where !association.Equals(priorityAssociation)
select association).ToArray <MailboxAssociation>();
PriorityReplicator.Tracer.TraceDebug <int>((long)this.GetHashCode(), "PriorityReplicator::ReplicateAssociations. Found {0} association to replicate via RPC", array.Length);
if (array.Length > 0)
{
flag &= this.defaultReplicator.ReplicateAssociation(masterAdaptor, array);
}
}
else
{
PriorityReplicator.Tracer.TraceDebug <int>((long)this.GetHashCode(), "PriorityReplicator::ReplicateAssociations. Priority association not found. Found {0} association to replicate via RPC", associations.Length);
flag &= this.defaultReplicator.ReplicateAssociation(masterAdaptor, associations);
}
return(flag);
}
public static int GetEscalatedAssociationsCount(IAssociationAdaptor adaptor)
{
GetEscalatedAssociations getEscalatedAssociations = new GetEscalatedAssociations(adaptor);
IEnumerable <MailboxAssociation> source = getEscalatedAssociations.Execute(null);
return(source.ToArray <MailboxAssociation>().Count <MailboxAssociation>());
}
private bool ReplicateSingleAssociation(IAssociationReplicator replicator, IAssociationAdaptor masterAdaptor, MailboxAssociation association)
{
QueuedInProcessAssociationReplicator.Tracer.TraceDebug <IAssociationAdaptor, MailboxAssociation>((long)this.GetHashCode(), "QueuedInProcessAssociationReplicator.ReplicateSingleAssociation: MasterAdaptor={0}, Association={1}.", masterAdaptor, association);
return(replicator.ReplicateAssociation(masterAdaptor, new MailboxAssociation[]
{
association
}));
}
public void TriggerReplication(IAssociationAdaptor masterAdaptor)
{
ReplicatorEnabledAssociationEnumerator.Tracer.TraceDebug <int>((long)this.GetHashCode(), "ReplicatorEnabledAssociationEnumerator.TriggerReplication: Found {0} associations out of sync", this.outOfSyncAssociations.Count);
if (this.outOfSyncAssociations.Count > 0)
{
this.replicator.ReplicateAssociation(masterAdaptor, this.outOfSyncAssociations.ToArray());
}
}
protected UpdateAssociationCommand(IExtensibleLogger logger, IAssociationAdaptor masterAdaptor, params IMailboxLocator[] itemLocators)
{
ArgumentValidator.ThrowIfNull("logger", logger);
ArgumentValidator.ThrowIfNull("masterAdaptor", masterAdaptor);
ArgumentValidator.ThrowIfNull("itemLocators", itemLocators);
ArgumentValidator.ThrowIfZeroOrNegative("itemLocators.Length", itemLocators.Length);
this.MasterAdaptor = masterAdaptor;
this.Logger = logger;
this.ItemLocators = itemLocators;
}
private MailboxAssociation GetAssociationWithPriority(IAssociationAdaptor masterAdaptor, params MailboxAssociation[] associations)
{
MailboxAssociation result = null;
if (this.priorityLocator != null)
{
result = associations.FirstOrDefault((MailboxAssociation association) => this.ShouldPrioritize(masterAdaptor.GetSlaveMailboxLocator(association)));
}
return(result);
}
public bool ReplicateAssociation(IAssociationAdaptor masterAdaptor, params MailboxAssociation[] associations)
{
ArgumentValidator.ThrowIfNull("associations", associations);
ArgumentValidator.ThrowIfZeroOrNegative("associations.Length", associations.Length);
QueuedInProcessAssociationReplicator.Tracer.TraceDebug <int>((long)this.GetHashCode(), "QueuedInProcessAssociationReplicator::ReplicateAssociation. Enqueuing {0} associations to replicate in the background.", associations.Length);
masterAdaptor.AssociationStore.SaveMailboxAsOutOfSync();
foreach (MailboxAssociation item in associations)
{
this.pendingAssociations.Enqueue(item);
}
return(true);
}
private void ReplicateOutOfSyncAssociation(Func <IAssociationStore, IAssociationAdaptor> associationAdaptorCreator, IMailboxLocator masterLocator, params IMailboxLocator[] slaveLocators)
{
ArgumentValidator.ThrowIfNull("masterLocator", masterLocator);
ArgumentValidator.ThrowIfNull("slaveLocators", slaveLocators);
ArgumentValidator.ThrowIfZeroOrNegative("slaveLocators.Length", slaveLocators.Length);
GroupMailboxAccessLayer.Tracer.TraceDebug <IMailboxLocator, int>((long)this.GetHashCode(), "GroupMailboxAccessLayer::ReplicateOutOfSyncAssociation. Replicating data from mailbox: {0}. Number of out of sync mailboxes: {1}", masterLocator, slaveLocators.Length);
using (IAssociationStore associationStore = this.storeProviderBuilder.Create(masterLocator, this.PerformanceTracker))
{
IAssociationAdaptor associationAdaptor = associationAdaptorCreator(associationStore);
InProcessAssociationReplicator replicator = new InProcessAssociationReplicator(this.Logger, this.PerformanceTracker, OpenAsAdminOrSystemServiceBudgetTypeType.RunAsBackgroundLoad);
ICollection <MailboxAssociation> associations = slaveLocators.Select(new Func <IMailboxLocator, MailboxAssociation>(associationAdaptor.GetAssociation));
this.ReplicateAssociations(replicator, associationAdaptor, associations);
}
}
public bool ReplicateAssociation(IAssociationAdaptor masterAdaptor, params MailboxAssociation[] associations)
{
ArgumentValidator.ThrowIfNull("associations", associations);
ArgumentValidator.ThrowIfZeroOrNegative("associations.Length", associations.Length);
RpcAssociationReplicator.Tracer.TraceDebug((long)this.GetHashCode(), "RpcAssociationReplicator::ReplicateAssociations");
try
{
return(this.replicationAssistantInvoker.Invoke("RpcAssociationReplicator", masterAdaptor, associations));
}
catch (GrayException ex)
{
this.LogError(ex.ToString());
masterAdaptor.AssociationStore.SaveMailboxAsOutOfSync();
}
return(false);
}
public bool Invoke(string command, IAssociationAdaptor masterAdaptor, params MailboxAssociation[] associations)
{
ArgumentValidator.ThrowIfNull("masterAdaptor", masterAdaptor);
ADUser masterMailbox = masterAdaptor.MasterLocator.FindAdUser();
bool isRpcCallSuccessful = false;
GrayException.MapAndReportGrayExceptions(delegate()
{
try
{
MailboxLocator[] array = associations.Select(new Func <MailboxAssociation, MailboxLocator>(masterAdaptor.GetSlaveMailboxLocator)).ToArray <MailboxLocator>();
this.logger.LogEvent(new SchemaBasedLogEvent <MailboxAssociationLogSchema.CommandExecution>
{
{
MailboxAssociationLogSchema.CommandExecution.Command,
command
},
{
MailboxAssociationLogSchema.CommandExecution.GroupMailbox,
masterAdaptor.MasterLocator
},
{
MailboxAssociationLogSchema.CommandExecution.UserMailboxes,
array
}
});
RpcAssociationReplicatorRunNowParameters rpcAssociationReplicatorRunNowParameters = new RpcAssociationReplicatorRunNowParameters
{
SlaveMailboxes = array
};
ReplicationAssistantInvoker.Tracer.TraceDebug <string, RpcAssociationReplicatorRunNowParameters>((long)this.GetHashCode(), "ReplicationAssistantInvoker::ReplicateAssociations. Calling RpcAssociationReplicator in '{0}' with parameter: '{1}'", this.targetServerFqdn, rpcAssociationReplicatorRunNowParameters);
using (AssistantsRpcClient assistantsRpcClient = new AssistantsRpcClient(this.targetServerFqdn))
{
assistantsRpcClient.StartWithParams("MailboxAssociationReplicationAssistant", masterMailbox.ExchangeGuid, masterMailbox.Database.ObjectGuid, rpcAssociationReplicatorRunNowParameters.ToString());
}
isRpcCallSuccessful = true;
}
catch (RpcException ex)
{
this.LogError(Strings.RpcReplicationCallFailed(ex.ErrorCode));
masterAdaptor.AssociationStore.SaveMailboxAsOutOfSync();
}
});
return(isRpcCallSuccessful);
}
private void ReplicateOutOfSyncAssociation(Func <IAssociationStore, IAssociationAdaptor> associationAdaptorCreator, IMailboxLocator masterLocator)
{
ArgumentValidator.ThrowIfNull("masterLocator", masterLocator);
GroupMailboxAccessLayer.Tracer.TraceDebug <IMailboxLocator>((long)this.GetHashCode(), "GroupMailboxAccessLayer::ReplicateOutOfSyncAssociation. Replicating data from mailbox: {0}.", masterLocator);
using (IAssociationStore storeProvider = this.storeProviderBuilder.Create(masterLocator, this.PerformanceTracker))
{
IAssociationAdaptor associationAdaptor = associationAdaptorCreator(storeProvider);
InProcessAssociationReplicator replicator = new InProcessAssociationReplicator(this.Logger, this.PerformanceTracker, OpenAsAdminOrSystemServiceBudgetTypeType.RunAsBackgroundLoad);
IEnumerable <MailboxAssociation> associations = from association in associationAdaptor.GetAllAssociations()
where association.IsOutOfSync(storeProvider.MailboxLocator.IdentityHash)
select association;
if (this.ReplicateAssociations(replicator, associationAdaptor, associations))
{
GroupMailboxAccessLayer.Tracer.TraceDebug((long)this.GetHashCode(), "GroupMailboxAccessLayer::ReplicateOutOfSyncAssociation. All replication succeeded. Clearing mailbox flags");
ExDateTime nextReplicationTime = ExDateTime.UtcNow.Add(GroupMailboxAccessLayer.TimeBetweenMailboxReplicationProcessing);
storeProvider.SaveMailboxSyncStatus(nextReplicationTime);
}
else
{
GroupMailboxAccessLayer.Tracer.TraceError((long)this.GetHashCode(), "GroupMailboxAccessLayer::ReplicateOutOfSyncAssociation. Not all replication succeeded. Keeping out of sync flags.");
}
}
}
private void SaveAssociationAfterReplicationAttempt(IAssociationAdaptor masterAdaptor, MailboxAssociation association)
{
Exception exceptionToLog = null;
try
{
GrayException.MapAndReportGrayExceptions(delegate()
{
try
{
masterAdaptor.SaveSyncState(association);
}
catch (StoragePermanentException exceptionToLog2)
{
exceptionToLog = exceptionToLog2;
}
catch (MapiPermanentException exceptionToLog3)
{
exceptionToLog = exceptionToLog3;
}
catch (StorageTransientException exceptionToLog4)
{
exceptionToLog = exceptionToLog4;
}
});
}
catch (GrayException exceptionToLog)
{
GrayException exceptionToLog5;
exceptionToLog = exceptionToLog5;
}
if (exceptionToLog != null)
{
this.LogError("SaveAssociationAfterReplicationAttempt", exceptionToLog.ToString());
}
}
internal bool UpdateAssociation(MailboxAssociationFromStore association, IAssociationAdaptor associationAdaptor)
{
bool result = false;
MailboxLocator slaveMailboxLocator = associationAdaptor.GetSlaveMailboxLocator(association);
if (base.IsChanged(MailboxAssociationPresentationObject.MailboxAssociationPresentationObjectSchema.ExternalId))
{
slaveMailboxLocator.ExternalId = this.ExternalId;
}
if (base.IsChanged(MailboxAssociationPresentationObject.MailboxAssociationPresentationObjectSchema.LegacyDn))
{
slaveMailboxLocator.LegacyDn = this.LegacyDn;
}
if (base.IsChanged(MailboxAssociationPresentationObject.MailboxAssociationPresentationObjectSchema.IsMember))
{
association.IsMember = this.IsMember;
}
if (base.IsChanged(MailboxAssociationPresentationObject.MailboxAssociationPresentationObjectSchema.JoinedBy))
{
association.JoinedBy = this.JoinedBy;
}
if (base.IsChanged(MailboxAssociationPresentationObject.MailboxAssociationPresentationObjectSchema.GroupSmtpAddress))
{
association.GroupSmtpAddress = this.GroupSmtpAddress;
}
if (base.IsChanged(MailboxAssociationPresentationObject.MailboxAssociationPresentationObjectSchema.UserSmtpAddress))
{
association.UserSmtpAddress = this.UserSmtpAddress;
}
if (base.IsChanged(MailboxAssociationPresentationObject.MailboxAssociationPresentationObjectSchema.IsPin))
{
association.IsPin = this.IsPin;
}
if (base.IsChanged(MailboxAssociationPresentationObject.MailboxAssociationPresentationObjectSchema.ShouldEscalate))
{
association.ShouldEscalate = this.ShouldEscalate;
}
if (base.IsChanged(MailboxAssociationPresentationObject.MailboxAssociationPresentationObjectSchema.IsAutoSubscribed))
{
association.IsAutoSubscribed = this.IsAutoSubscribed;
}
if (base.IsChanged(MailboxAssociationPresentationObject.MailboxAssociationPresentationObjectSchema.JoinDate))
{
association.JoinDate = this.JoinDate;
}
if (base.IsChanged(MailboxAssociationPresentationObject.MailboxAssociationPresentationObjectSchema.LastVisitedDate))
{
association.LastVisitedDate = this.LastVisitedDate;
}
if (base.IsChanged(MailboxAssociationPresentationObject.MailboxAssociationPresentationObjectSchema.PinDate))
{
association.PinDate = this.PinDate;
}
if (base.IsChanged(MailboxAssociationPresentationObject.MailboxAssociationPresentationObjectSchema.CurrentVersion))
{
association.CurrentVersion = this.CurrentVersion;
result = true;
}
if (base.IsChanged(MailboxAssociationPresentationObject.MailboxAssociationPresentationObjectSchema.SyncedVersion))
{
association.SyncedVersion = this.SyncedVersion;
result = true;
}
if (base.IsChanged(MailboxAssociationPresentationObject.MailboxAssociationPresentationObjectSchema.LastSyncError))
{
association.LastSyncError = this.LastSyncError;
result = true;
}
if (base.IsChanged(MailboxAssociationPresentationObject.MailboxAssociationPresentationObjectSchema.SyncAttempts))
{
association.SyncAttempts = this.SyncAttempts;
result = true;
}
if (base.IsChanged(MailboxAssociationPresentationObject.MailboxAssociationPresentationObjectSchema.SyncedSchemaVersion))
{
association.SyncedSchemaVersion = this.SyncedSchemaVersion;
result = true;
}
return(result);
}
public GetEscalatedAssociations(IAssociationAdaptor adaptor)
{
this.AssociationAdaptor = adaptor;
}
public GetMembershipAssociations(IAssociationAdaptor adaptor)
{
this.AssociationAdaptor = adaptor;
}
private bool ReplicateAssociations(InProcessAssociationReplicator replicator, IAssociationAdaptor associationAdaptor, IEnumerable <MailboxAssociation> associations)
{
ArgumentValidator.ThrowIfNull("replicator", replicator);
ArgumentValidator.ThrowIfNull("associationAdaptor", associationAdaptor);
ArgumentValidator.ThrowIfNull("associations", associations);
bool flag = true;
foreach (MailboxAssociation mailboxAssociation in associations)
{
GroupMailboxAccessLayer.Tracer.TraceDebug <MailboxAssociation>((long)this.GetHashCode(), "GroupMailboxAccessLayer::ReplicateAssociations. Replicating association {0}", mailboxAssociation);
flag &= replicator.ReplicateAssociation(associationAdaptor, new MailboxAssociation[]
{
mailboxAssociation
});
}
return(flag);
}
public GetMembershipChangedAfterAssociations(IAssociationAdaptor adaptor, ExDateTime date)
{
this.AssociationAdaptor = adaptor;
this.changeDate = date;
}
public GetPinAssociations(IAssociationAdaptor adaptor)
{
this.AssociationAdaptor = adaptor;
}
public bool ReplicateAssociation(IAssociationAdaptor masterAdaptor, params MailboxAssociation[] associations)
{
ArgumentValidator.ThrowIfNull("associations", associations);
ArgumentValidator.ThrowIfOutOfRange <int>("associations", associations.Length, 1, 1);
ArgumentValidator.ThrowIfNull("masterAdaptor", masterAdaptor);
MailboxAssociation mailboxAssociation = associations[0];
InProcessAssociationReplicator.Tracer.TraceDebug <MailboxAssociation>((long)this.GetHashCode(), "InProcessAssociationReplicator::ReplicateAssociations: {0}", mailboxAssociation);
this.Logger.LogEvent(new SchemaBasedLogEvent <MailboxAssociationLogSchema.CommandExecution>
{
{
MailboxAssociationLogSchema.CommandExecution.Command,
"InProcessAssociationReplicator"
},
{
MailboxAssociationLogSchema.CommandExecution.GroupMailbox,
mailboxAssociation.Group
},
{
MailboxAssociationLogSchema.CommandExecution.UserMailboxes,
mailboxAssociation.User
}
});
this.PerformanceTracker.IncrementAssociationReplicationAttempts();
MailboxLocator slaveMailboxLocator = masterAdaptor.GetSlaveMailboxLocator(mailboxAssociation);
bool flag = false;
try
{
if (slaveMailboxLocator.IsValidReplicationTarget())
{
flag = this.ExecuteReplicationToMailbox(masterAdaptor, mailboxAssociation);
}
else
{
InProcessAssociationReplicator.Tracer.TraceDebug <MailboxAssociation>((long)this.GetHashCode(), "InProcessAssociationReplicator.ReplicateAssociation. Marking association for not replication given target type. Association = {0}", mailboxAssociation);
this.Logger.LogEvent(new SchemaBasedLogEvent <MailboxAssociationLogSchema.CommandExecution>
{
{
MailboxAssociationLogSchema.CommandExecution.Command,
"InProcessAssociationReplicator.MEU.Poison"
},
{
MailboxAssociationLogSchema.CommandExecution.GroupMailbox,
mailboxAssociation.Group
},
{
MailboxAssociationLogSchema.CommandExecution.UserMailboxes,
mailboxAssociation.User
}
});
mailboxAssociation.SyncedVersion = int.MaxValue;
mailboxAssociation.LastSyncError = "Target mailbox is not capable of replication";
flag = true;
}
}
catch (MailboxNotFoundException ex)
{
if (this.DeleteMailboxNotFoundAssociation(mailboxAssociation, masterAdaptor, ex))
{
InProcessAssociationReplicator.Tracer.TraceDebug((long)this.GetHashCode(), "InProcessAssociationReplicator.ReplicateAssociation. Succeeded deleting association for not found mailbox, reporting successful replication and skipping SaveAssociationAfterReplicationAttempt.");
return(true);
}
this.ProcessFailure(mailboxAssociation, ex.ToString());
}
if (!flag)
{
masterAdaptor.AssociationStore.SaveMailboxAsOutOfSync();
}
this.SaveAssociationAfterReplicationAttempt(masterAdaptor, mailboxAssociation);
return(flag);
}
private bool ExecuteReplicationToMailbox(IAssociationAdaptor masterAdaptor, MailboxAssociation association)
{
bool replicationSucceeded = false;
Exception exception = null;
try
{
GrayException.MapAndReportGrayExceptions(delegate()
{
try
{
MailboxAssociationEwsBinding.ExecuteEwsOperationWithRetry("ReplicateAssociation", delegate
{
using (MailboxAssociationEwsBinding mailboxAssociationEwsBinding = this.CreateMailboxAssociationEwsBinding(masterAdaptor.MasterLocator, association))
{
UpdateMailboxAssociationType updateMailboxAssociation = InProcessAssociationReplicator.CreateUpdateMailboxAssociationType(masterAdaptor.MasterLocator, association);
UpdateMailboxAssociationResponseType response = mailboxAssociationEwsBinding.UpdateMailboxAssociation(updateMailboxAssociation);
replicationSucceeded = this.ProcessResponse(mailboxAssociationEwsBinding, response, association, masterAdaptor.AssociationStore.MailboxLocator);
}
});
}
catch (MailboxNotFoundException exception4)
{
replicationSucceeded = this.DeleteMailboxNotFoundAssociation(association, masterAdaptor, exception4);
if (!replicationSucceeded)
{
exception = exception4;
}
}
catch (BackEndLocatorException exception5)
{
exception = exception5;
}
catch (WebException exception6)
{
exception = exception6;
}
catch (InvalidOperationException exception7)
{
exception = exception7;
}
catch (LogonAsNetworkServiceException exception8)
{
if (!ExEnvironment.IsTest)
{
throw;
}
exception = exception8;
}
});
}
catch (GrayException exception)
{
GrayException exception9;
exception = exception9;
}
catch (SoapException exception2)
{
exception = exception2;
}
catch (IOException exception3)
{
exception = exception3;
}
if (exception != null)
{
this.ProcessFailure(association, exception.ToString());
replicationSucceeded = false;
}
return(replicationSucceeded);
}
private void DeleteMailboxAssociation(MailboxAssociationFromStore association, IAssociationAdaptor associationAdaptor, ADUser masterMailbox, IExtensibleLogger logger)
{
if (association != null)
{
associationAdaptor.DeleteAssociation(association);
return;
}
base.WriteError(new ManagementObjectNotFoundException(base.GetErrorMessageObjectNotFound(this.Identity.AssociationIdValue, typeof(MailboxAssociationPresentationObject).ToString(), this.Identity.MailboxId.ToString())), ExchangeErrorCategory.Client, this.Identity);
}
private bool DeleteMailboxNotFoundAssociation(MailboxAssociation association, IAssociationAdaptor masterAdaptor, MailboxNotFoundException exception)
{
bool flag = association.JoinDate.Add(InProcessAssociationReplicator.TimeRequiredAfterJoinToStopAssociationReplicationAttempts) < ExDateTime.UtcNow;
InProcessAssociationReplicator.Tracer.TraceDebug <bool, MailboxNotFoundException, MailboxAssociation>((long)this.GetHashCode(), "InProcessAssociationReplicator.DeleteMailboxNotFoundAssociation. Should delete = {0}. Exception = {1}. Association = {2}", flag, exception, association);
if (flag)
{
this.LogWarning("InProcessAssociationReplicator.DeleteMailboxNotFoundAssociation", string.Format("Deleting association given that target mailbox was not found and it is not a recently joined group. Association='{0}'. Exception='{1}'", association, exception));
masterAdaptor.DeleteAssociation(association);
return(true);
}
return(false);
}
private void WriteMailboxAssociation(MailboxAssociationFromStore association, IAssociationAdaptor associationAdaptor, ADUser masterMailbox, IExtensibleLogger logger)
{
if (association != null)
{
ObjectId objectId = new MailboxStoreObjectId(masterMailbox.ObjectId, association.ItemId.ObjectId);
MailboxLocator slaveMailboxLocator = associationAdaptor.GetSlaveMailboxLocator(association);
if (base.NeedSuppressingPiiData)
{
objectId = SuppressingPiiData.RedactMailboxStoreObjectId(objectId);
}
base.WriteResult(new MailboxAssociationPresentationObject
{
Identity = objectId,
ExternalId = slaveMailboxLocator.ExternalId,
LegacyDn = slaveMailboxLocator.LegacyDn,
IsMember = association.IsMember,
JoinedBy = association.JoinedBy,
GroupSmtpAddress = association.GroupSmtpAddress,
UserSmtpAddress = association.UserSmtpAddress,
IsPin = association.IsPin,
ShouldEscalate = association.ShouldEscalate,
IsAutoSubscribed = association.IsAutoSubscribed,
JoinDate = association.JoinDate,
LastVisitedDate = association.LastVisitedDate,
PinDate = association.PinDate,
LastModified = association.LastModified,
CurrentVersion = association.CurrentVersion,
SyncedVersion = association.SyncedVersion,
LastSyncError = association.LastSyncError,
SyncAttempts = association.SyncAttempts,
SyncedSchemaVersion = association.SyncedSchemaVersion
});
return;
}
GetMailboxAssociation.Tracer.TraceDebug((long)this.GetHashCode(), "GetMailboxAssocaition.WriteMailboxAssociation. Skipping null MailboxAssociationFromStore.");
}
public GetMemberAssociation(IAssociationAdaptor adaptor, IMailboxLocator user)
{
this.user = user;
this.associationAdaptor = adaptor;
}
private void UpdateMailboxAssociation(MailboxAssociationFromStore association, IAssociationAdaptor associationAdaptor, ADUser masterMailbox, IExtensibleLogger logger)
{
if (association == null)
{
SetMailboxAssociation.Tracer.TraceDebug((long)this.GetHashCode(), "SetMailboxAssocaition.UpdateMailboxAssociation. Skipping null MailboxAssociationFromStore.");
return;
}
bool flag = this.Instance.UpdateAssociation(association, associationAdaptor);
associationAdaptor.SaveAssociation(association, this.ReplicateMasteredData);
if (this.UpdateSlavedData)
{
associationAdaptor.ReplicateAssociation(association);
}
if (flag)
{
associationAdaptor.SaveSyncState(association);
}
if (this.ReplicateMasteredData)
{
RpcAssociationReplicator rpcAssociationReplicator = new RpcAssociationReplicator(logger, associationAdaptor.AssociationStore.ServerFullyQualifiedDomainName);
rpcAssociationReplicator.ReplicateAssociation(associationAdaptor, new MailboxAssociation[]
{
association
});
}
}
