Réplication SQL Server - RMO de SMO

Lorsque l'on réalise certains développements, nous sommes amenés à rencontrer les réplications SQL Server avec des contraintes de licences compte tenu des budgets disponibles.

J'ai rencontré cela en souhaitant mettre en place une réplication de fusion entre un sql server 2005 workgroup et un serveur sql express.

Le problème que l'on se rend compte très rapidement c'est que le sql server express ne dispose pas d'agent.
Alors, on commence à explorer d'autres pistes : la réplication transactionelle bidirectionnelle ! Chouette ! Ca fonctionne avec sql express après avoir paramétré msdtc convenablement! Seul contrainte à cela c'est qu'en cas de coupure de lien entre les deux serveurs, plus aucun enregistrements n'est réalisable ...
Retour arrière, il faut utiliser une réplication de fusion, de façon à pouvoir travailler en mode déconnecté (sur une GPAO ce n'est pas négligeable). Deux solutions, soit j'essaie de faire en sorte pour trouver le budget pour une seconde licence ... soit je me débrouille autrement pour faire un "agent".
Et c'est là qu'intervient RMO (Replication Management Object) de SMO (Sql Server Management Object).
Avec ces objets, il est possible de réaliser un pseudo agent grâce à une petite application c#.

Voici un petit bout de code qui permet :
1) de réaliser l'abonnement
2) de déclencher les réplications (reste à faire une tâche planifiée)


public class RMO
{
///

/// Launch a client merge replication (as a sql agent done)
///

/// Subscriber instance name
/// Publisher instance name
/// Publication name
/// Publication DB Name
/// Subscription DB Name
/// Indicate if it is necessary to create subscription
public static void MergePushReplic(string subscriberName, string publisherName, string publicationName, string publicationDbName, string subscriptionDbName, bool createSubscription)
{

// Create a connection to the Publisher.
ServerConnection connPub = new ServerConnection(publisherName);
ServerConnection connSub = new ServerConnection(subscriberName);
MergePublication publication;
MergePullSubscription subscription;

try
{

connPub.Connect();
connSub.Connect();


publication = new MergePublication(publicationName, publicationDbName, connPub);

if (publication.LoadProperties())
{
if ((publication.Attributes & PublicationAttributes.AllowPull) == 0)
{
publication.Attributes |= PublicationAttributes.AllowPull;
}


subscription = new MergePullSubscription(subscriptionDbName, publisherName, publicationDbName, publicationName, connSub);
subscription.SynchronizationAgentProcessSecurity.Login = @"";
subscription.SynchronizationAgentProcessSecurity.Password = "";
subscription.CreateSyncAgentByDefault = true;


if (createSubscription)
subscription.Create();

Boolean registered = false;

// Verify that the subscription is not already registered.
foreach (MergeSubscription existing
in publication.EnumSubscriptions())
{
if (existing.SubscriberName == subscriberName
&& existing.SubscriptionDBName == subscriptionDbName
&& existing.SubscriptionType == SubscriptionOption.Pull)
{
registered = true;
}
}
/*
if (!registered)
{
// Register the local subscription with the Publisher.
publication.MakePullSubscriptionWellKnown(
subscriberName, subscriptionDbName,
SubscriptionSyncType.None,
MergeSubscriberType.Local, 0);
}
*/
// Check that we have enough metadata to start the agent.
if (subscription.SubscriberSecurity != null)
{
subscription.SynchronizationAgent.PublisherSecurityMode = SecurityMode.Integrated;
subscription.SynchronizationAgent.DistributorSecurityMode = SecurityMode.Integrated;
subscription.SynchronizationAgent.OutputVerboseLevel = 1;
subscription.SynchronizationAgent.Output = "c:\\replic.log";
// Synchronously start the Merge Agent for the subscription.
subscription.SynchronizationAgent.Synchronize();

}
else
{
throw new ApplicationException("There is insufficent metadata to " +
"synchronize the subscription. Recreate the subscription with " +
"the agent job or supply the required agent properties at run time.");
}
}
else
{
// Do something here if the push subscription does not exist.
throw new ApplicationException(String.Format(
"The subscription to '{0}' does not exist on {1}",
publicationName, subscriberName));
}
}
catch (Exception ex)
{
// Implement appropriate error handling here.
throw new ApplicationException("The subscription could not be synchronized.", ex);

}
finally
{
connPub.Disconnect();
connSub.Disconnect();
}


}

}

En attendant, voici un petit lien fort utile :
http://msdn2.microsoft.com/en-us/library/microsoft.sqlserver.replication.aspx