private static void ReplicateChanges(IReplicationSession replication, IReplicationProvider provider)
{
IObjectSet changes = provider.ObjectsChangedSinceLastReplication();
foreach (object changedObject in changes)
{
replication.Replicate(changedObject);
}
}
private void Replicate(IReplicationSession replication, string originName)
{
IReplicationProvider origin = Container(originName);
IReplicationProvider destination = Container(Other(originName));
if (!_containersToQueryFrom.Contains(originName))
{
return;
}
ReplicateQueryingFrom(replication, origin, destination);
}
public void SetDirection(IReplicationProvider replicateFrom, IReplicationProvider
replicateTo)
{
if (replicateFrom == _providerA && replicateTo == _providerB)
{
_directionTo = _providerB;
}
if (replicateFrom == _providerB && replicateTo == _providerA)
{
_directionTo = _providerA;
}
}
public GenericReplicationSession(IReplicationProvider providerA, IReplicationProvider
providerB, IReplicationEventListener listener, IReflector reflector)
{
//null means bidirectional replication.
_reflector = new ReplicationReflector(providerA, providerB, reflector);
_collectionHandler = new CollectionHandlerImpl(_reflector);
_traverser = new GenericTraverser(_reflector, _collectionHandler);
_providerA = (IReplicationProviderInside)providerA;
_providerB = (IReplicationProviderInside)providerB;
_listener = listener;
RunIsolated(new _IBlock4_73(this));
}
public GenericReplicationSession(IReplicationProvider providerA, IReplicationProvider
providerB, IReplicationEventListener listener, IReflector reflector)
{
//null means bidirectional replication.
_reflector = new ReplicationReflector(providerA, providerB, reflector);
_collectionHandler = new CollectionHandlerImpl(_reflector);
_traverser = new GenericTraverser(_reflector, _collectionHandler);
_providerA = (IReplicationProviderInside)providerA;
_providerB = (IReplicationProviderInside)providerB;
_listener = listener;
RunIsolated(new _IBlock4_73(this));
}
/// <summary>
/// Begins a replication session between two ReplicationProviders using a
/// ReplicationEventListener and with a Reflector provided.
/// </summary>
/// <remarks>
/// Begins a replication session between two ReplicationProviders using a
/// ReplicationEventListener and with a Reflector provided.
/// </remarks>
/// <exception cref="ReplicationConflictException">when conflicts occur</exception>
/// <seealso cref="IReplicationEventListener">IReplicationEventListener</seealso>
public static IReplicationSession Begin(IReplicationProvider providerFrom, IReplicationProvider
providerTo, IReplicationEventListener listener, IReflector reflector)
{
if (listener == null)
{
listener = new DefaultReplicationEventListener();
}
ReplicationReflector rr = new ReplicationReflector(providerFrom, providerTo, reflector
);
providerFrom.ReplicationReflector(rr);
providerTo.ReplicationReflector(rr);
return new GenericReplicationSession(providerFrom, providerTo, listener, reflector
);
}
/// <summary>
/// Begins a replication session between two ReplicationProviders using a
/// ReplicationEventListener and with a Reflector provided.
/// </summary>
/// <remarks>
/// Begins a replication session between two ReplicationProviders using a
/// ReplicationEventListener and with a Reflector provided.
/// </remarks>
/// <exception cref="ReplicationConflictException">when conflicts occur</exception>
/// <seealso cref="IReplicationEventListener">IReplicationEventListener</seealso>
public static IReplicationSession Begin(IReplicationProvider providerFrom, IReplicationProvider
providerTo, IReplicationEventListener listener, IReflector reflector)
{
if (listener == null)
{
listener = new DefaultReplicationEventListener();
}
ReplicationReflector rr = new ReplicationReflector(providerFrom, providerTo, reflector
);
providerFrom.ReplicationReflector(rr);
providerTo.ReplicationReflector(rr);
return(new GenericReplicationSession(providerFrom, providerTo, listener, reflector
));
}
private IInternalObjectContainer ContainerFrom(IReplicationProvider provider)
{
if (!(provider is IDb4oReplicationProvider))
{
return(null);
}
IDb4oReplicationProvider db4oProvider = (IDb4oReplicationProvider)provider;
IExtObjectContainer container = db4oProvider.GetObjectContainer();
if (!(container is IInternalObjectContainer))
{
return(null);
}
return((IInternalObjectContainer)container);
}
public GenericReplicationSession(IReplicationProvider providerA, IReplicationProvider
providerB, IReplicationEventListener listener, IReflector reflector)
{
//null means bidirectional replication.
_reflector = new ReplicationReflector(providerA, providerB, reflector);
_collectionHandler = new CollectionHandlerImpl(_reflector);
_traverser = new GenericTraverser(_reflector, _collectionHandler);
_providerA = (IReplicationProviderInside)providerA;
_providerB = (IReplicationProviderInside)providerB;
_listener = listener;
_providerA.StartReplicationTransaction(_providerB.GetSignature());
_providerB.StartReplicationTransaction(_providerA.GetSignature());
long syncedTimeStamp = Math.Max(_providerA.TimeStamps().Commit(), _providerB.TimeStamps
().Commit());
_providerA.SyncCommitTimestamp(syncedTimeStamp);
_providerB.SyncCommitTimestamp(syncedTimeStamp);
}
public GenericReplicationSession(IReplicationProvider providerA, IReplicationProvider
providerB, IReplicationEventListener listener, IReflector reflector)
{
//null means bidirectional replication.
_reflector = new ReplicationReflector(providerA, providerB, reflector);
_collectionHandler = new CollectionHandlerImpl(_reflector);
_traverser = new GenericTraverser(_reflector, _collectionHandler);
_providerA = (IReplicationProviderInside)providerA;
_providerB = (IReplicationProviderInside)providerB;
_listener = listener;
_providerA.StartReplicationTransaction(_providerB.GetSignature());
_providerB.StartReplicationTransaction(_providerA.GetSignature());
long syncedTimeStamp = Math.Max(_providerA.TimeStamps().Commit(), _providerB.TimeStamps
().Commit());
_providerA.SyncCommitTimestamp(syncedTimeStamp);
_providerB.SyncCommitTimestamp(syncedTimeStamp);
}
internal InstanceReplicationPreparer(IReplicationProviderInside providerA, IReplicationProviderInside
providerB, IReplicationProvider directionTo, IReplicationEventListener listener
, bool isReplicatingOnlyDeletions, HashSet4 uuidsProcessedInSession, ITraverser
traverser, ReplicationReflector reflector, Db4objects.Drs.Inside.ICollectionHandler
collectionHandler)
{
_event = new ReplicationEventImpl();
_stateInA = _event._stateInProviderA;
_stateInB = _event._stateInProviderB;
_providerA = providerA;
_providerB = providerB;
_directionTo = directionTo;
_listener = listener;
_isReplicatingOnlyDeletions = isReplicatingOnlyDeletions;
_uuidsProcessedInSession = uuidsProcessedInSession;
_traverser = traverser;
_reflector = reflector;
_collectionHandler = collectionHandler;
}
internal InstanceReplicationPreparer(IReplicationProviderInside providerA, IReplicationProviderInside
providerB, IReplicationProvider directionTo, IReplicationEventListener listener
, bool isReplicatingOnlyDeletions, long lastReplicationVersion, HashSet4 uuidsProcessedInSession
, ITraverser traverser, ReplicationReflector reflector, Db4objects.Drs.Inside.ICollectionHandler
collectionHandler)
{
_event = new ReplicationEventImpl();
_stateInA = _event._stateInProviderA;
_stateInB = _event._stateInProviderB;
_providerA = providerA;
_providerB = providerB;
_directionTo = directionTo;
_listener = listener;
_isReplicatingOnlyDeletions = isReplicatingOnlyDeletions;
_lastReplicationVersion = lastReplicationVersion;
_uuidsProcessedInSession = uuidsProcessedInSession;
_traverser = traverser;
_reflector = reflector;
_collectionHandler = collectionHandler;
}
public ReplicationReflector(IReplicationProvider providerA, IReplicationProvider
providerB, IReflector reflector)
{
if (reflector == null)
{
if ((_container = ContainerFrom(providerA)) != null)
{
return;
}
if ((_container = ContainerFrom(providerB)) != null)
{
return;
}
}
GenericReflector genericReflector = new GenericReflector(null, reflector == null ?
Platform4.ReflectorForType(typeof(Db4objects.Drs.Inside.ReplicationReflector)) :
reflector);
Platform4.RegisterCollections(genericReflector);
_reflector = genericReflector;
}
public ReplicationReflector(IReplicationProvider providerA, IReplicationProvider
providerB, IReflector reflector)
{
if (reflector == null)
{
if ((_container = ContainerFrom(providerA)) != null)
{
return;
}
if ((_container = ContainerFrom(providerB)) != null)
{
return;
}
}
GenericReflector genericReflector = new GenericReflector(null, reflector == null ?
Platform4.ReflectorForType(typeof(Db4objects.Drs.Inside.ReplicationReflector)) :
reflector);
Platform4.RegisterCollections(genericReflector);
_reflector = genericReflector;
}
private void ReplicateQueryingFrom(IReplicationSession replication, IReplicationProvider
origin, IReplicationProvider other)
{
ReplicationConflictException exception = null;
IEnumerator changes = origin.ObjectsChangedSinceLastReplication().GetEnumerator();
while (changes.MoveNext())
{
object changed = changes.Current;
try
{
replication.Replicate(changed);
}
catch (ReplicationConflictException e)
{
exception = e;
}
}
if (exception != null)
{
throw exception;
}
}
private void ReplicateQueryingFrom(IReplicationSession replication, IReplicationProvider
origin, IReplicationProvider other)
{
ReplicationConflictException exception = null;
IEnumerator changes = origin.ObjectsChangedSinceLastReplication().GetEnumerator();
while (changes.MoveNext())
{
object changed = changes.Current;
try
{
replication.Replicate(changed);
}
catch (ReplicationConflictException e)
{
exception = e;
}
}
if (exception != null)
{
throw exception;
}
}
/// <summary>
/// Begins a replication session between two ReplicationProviders without a
/// ReplicationEventListener and with no Reflector provided.
/// </summary>
/// <remarks>
/// Begins a replication session between two ReplicationProviders without a
/// ReplicationEventListener and with no Reflector provided.
/// </remarks>
/// <exception cref="ReplicationConflictException">when conflicts occur</exception>
/// <seealso cref="IReplicationEventListener">IReplicationEventListener</seealso>
public static IReplicationSession Begin(IReplicationProvider providerA, IReplicationProvider
providerB)
{
return Begin(providerA, providerB, null, null);
}
/// <summary>
/// Begins a replication session between two ReplicationProviders without a
/// ReplicationEventListener and with no Reflector provided.
/// </summary>
/// <remarks>
/// Begins a replication session between two ReplicationProviders without a
/// ReplicationEventListener and with no Reflector provided.
/// </remarks>
/// <exception cref="ReplicationConflictException">when conflicts occur</exception>
/// <seealso cref="IReplicationEventListener">IReplicationEventListener</seealso>
public static IReplicationSession Begin(IReplicationProvider providerA, IReplicationProvider
providerB)
{
return(Begin(providerA, providerB, null, null));
}
/// <summary>
/// Begins a replication session between two ReplicationProviders using a
/// ReplicationEventListener and with no Reflector provided.
/// </summary>
/// <remarks>
/// Begins a replication session between two ReplicationProviders using a
/// ReplicationEventListener and with no Reflector provided.
/// </remarks>
/// <exception cref="ReplicationConflictException">when conflicts occur</exception>
/// <seealso cref="IReplicationEventListener">IReplicationEventListener</seealso>
public static IReplicationSession Begin(IReplicationProvider providerA, IReplicationProvider
providerB, IReplicationEventListener listener)
{
return(Begin(providerA, providerB, listener, null));
}
/// <summary>
/// Begins a replication session between two ReplicationProviders without a
/// ReplicationEventListener and with a Reflector provided.
/// </summary>
/// <remarks>
/// Begins a replication session between two ReplicationProviders without a
/// ReplicationEventListener and with a Reflector provided.
/// </remarks>
/// <exception cref="ReplicationConflictException">when conflicts occur</exception>
/// <seealso cref="IReplicationEventListener">IReplicationEventListener</seealso>
public static IReplicationSession Begin(IReplicationProvider providerFrom, IReplicationProvider
providerTo, IReflector reflector)
{
return(Begin(providerFrom, providerTo, null, reflector));
}
public GenericReplicationSession(IReplicationProvider providerA, IReplicationProvider
providerB, IReplicationEventListener listener) : this(providerA, providerB, listener
, null)
{
}
private static void ReplicateChanges(IReplicationSession replication, IReplicationProvider provider)
{
IObjectSet changes = provider.ObjectsChangedSinceLastReplication();
foreach (object changedObject in changes)
{
replication.Replicate(changedObject);
}
}
private IInternalObjectContainer ContainerFrom(IReplicationProvider provider)
{
if (!(provider is IDb4oReplicationProvider))
{
return null;
}
IDb4oReplicationProvider db4oProvider = (IDb4oReplicationProvider)provider;
IExtObjectContainer container = db4oProvider.GetObjectContainer();
if (!(container is IInternalObjectContainer))
{
return null;
}
return (IInternalObjectContainer)container;
}
/// <summary>
/// Begins a replication session between two ReplicationProviders using a
/// ReplicationEventListener and with no Reflector provided.
/// </summary>
/// <remarks>
/// Begins a replication session between two ReplicationProviders using a
/// ReplicationEventListener and with no Reflector provided.
/// </remarks>
/// <exception cref="ReplicationConflictException">when conflicts occur</exception>
/// <seealso cref="IReplicationEventListener">IReplicationEventListener</seealso>
public static IReplicationSession Begin(IReplicationProvider providerA, IReplicationProvider
providerB, IReplicationEventListener listener)
{
return Begin(providerA, providerB, listener, null);
}
public GenericReplicationSession(IReplicationProvider providerA, IReplicationProvider
providerB, IReplicationEventListener listener) : this(providerA, providerB, listener
, null)
{
}
/// <summary>
/// Begins a replication session between two ReplicationProviders without a
/// ReplicationEventListener and with a Reflector provided.
/// </summary>
/// <remarks>
/// Begins a replication session between two ReplicationProviders without a
/// ReplicationEventListener and with a Reflector provided.
/// </remarks>
/// <exception cref="ReplicationConflictException">when conflicts occur</exception>
/// <seealso cref="IReplicationEventListener">IReplicationEventListener</seealso>
public static IReplicationSession Begin(IReplicationProvider providerFrom, IReplicationProvider
providerTo, IReflector reflector)
{
return Begin(providerFrom, providerTo, null, reflector);
}
public void SetDirection(IReplicationProvider replicateFrom, IReplicationProvider
replicateTo)
{
if (replicateFrom == _providerA && replicateTo == _providerB)
{
_directionTo = _providerB;
}
if (replicateFrom == _providerB && replicateTo == _providerA)
{
_directionTo = _providerA;
}
}
