private List <DbSyncScopeDescription> ObtenerAmbitosAProcesar(ParametrosReplica parametros)
{
Loguear("Inicia proceso de obtener ambitos a procesar.");
List <DbSyncScopeDescription> ambitos = new List <DbSyncScopeDescription>();
var strConexionSql = (parametros.UsarDescripcionLocal) ? parametros.StringConnectionLocal : parametros.StringConnectionRemoto;
var connectionSQL = GetSQLConnection(strConexionSql);
foreach (string tabla in parametros.ListaDeTablas)
{
var tablaSplit = tabla.Split('.');
var schema = tablaSplit[0];
var nombreTabla = tablaSplit[1];
var scopeName = String.Format(_prefijoParaNombreDeAmbito, schema, nombreTabla);
try
{
var ambito = CrearAmbito(scopeName, tabla, connectionSQL);
ambitos.Add(ambito);
}
catch (Exception e)
{
Loguear($"Error al crear el ambito: [{scopeName}] /r/n{e.ToString()}");
}
}
CloseSQLConnection(connectionSQL);
Loguear("Finalizado proceso de obtener ambitos a procesar, ambitos creados: " + ambitos.Count);
return(ambitos);
}
private void ReplicarAmbitos(List <DbSyncScopeDescription> Ambitos, ParametrosReplica parameters) //int timeOut, uint tamañoDeCache)
{
_replicationSemaphore = new Semaphore(parameters.HilosParaReplicar, parameters.HilosParaReplicar);
foreach (DbSyncScopeDescription ambito in Ambitos)
{
try
{
_replicationSemaphore.WaitOne();
Loguear("Inicia thread para replicar el ambito: " + ambito.ScopeName);
Thread t = new Thread(() =>
{
StartReplicationOfOneScope(parameters, ambito);
});
HilosEnEjecucion.Add(t);
t.Start();
}
catch (Exception error)
{
Loguear("Error al ejecutar el hilo de replicar el ambito: " + ambito.ScopeName + " Error: " + error.ToString());
}
}
var threadCount = 1;
while (threadCount > 0)
{
Thread.Sleep(500);
threadCount = HilosEnEjecucion.FindAll(x => x.IsAlive).Count;
}
}
private void MantenerAprovisionamientoDeAmbitosEnHilos(ParametrosReplica parametros, string esquemaMetadataSyncFramework, string prefijoMetadataSyncFramework, List <DbSyncScopeDescription> Ambitos)
{
if (!(parametros.DesaprovisionarAmbitosEnServidorLocal || parametros.AprovisionarAmbitosEnServidorLocal || parametros.DesaprovisionarAmbitosEnServidorRemoto || parametros.AprovisionarAmbitosEnServidorRemoto))
{
return;
}
_semaphore = new Semaphore(parametros.HilosParaAprovisionar, parametros.HilosParaAprovisionar);
foreach (DbSyncScopeDescription ambito in Ambitos)
{
DbSyncScopeDescription LocalAmbito = ambito;
Thread t = new Thread(() =>
{
MantenerAprovisionamientoDeAmbitos(parametros, esquemaMetadataSyncFramework, prefijoMetadataSyncFramework, LocalAmbito);
});
HilosEnEjecucion.Add(t);
t.Start();
}
var threadCount = 1;
while (threadCount > 0)
{
Thread.Sleep(500);
threadCount = HilosEnEjecucion.FindAll(x => x.IsAlive).Count;
}
}
private void CargarParametros()
{
_parametrosReplica = new ParametrosReplica
{
AprovisionarAmbitosEnServidorLocal = this.chkAprovisionarAmbitosEnServidorLocal.Checked,
AprovisionarAmbitosEnServidorRemoto = this.chkAprovisionarAmbitosEnServidorRemoto.Checked,
DesaprovisionarAmbitosEnServidorLocal = this.chkDesaprovisionarAmbitosEnServidorLocal.Checked,
DesaprovisionarAmbitosEnServidorRemoto = this.chkDesaprovisionarAmbitosEnServidorRemoto.Checked,
LimpiarServidorLocal = this.chkLimpiarServidorLocal.Checked,
LimpiarServidorRemoto = this.chkLimpiarServidorRemoto.Checked,
RealizarReplica = this.chkReplicar.Checked,
StringConnectionLocal =
this.txtStringConnectionLocal.Text + ";Application Name=Manager de Sync Framework;",
StringConnectionRemoto =
this.txtStringConnectionRemoto.Text + ";Application Name=Manager de Sync Framework;",
ListaDeTablas = this.ObtenerListaDeTablas(this.lctChkTablasLocalesAReplicar.CheckedItems),
SitioDeSubida = this.chkSitioLocalDeSubida.Checked,
TamañoDeCache = Convert.ToUInt32(this.txtTamañoCache.Text.ToString()),
TamañoDeTransaccion = Convert.ToUInt32(this.txtTamañoTransaccion.Text.ToString()),
TimeOut = Convert.ToInt32(this.txtTimeOut.Text.ToString()),
prefijoMetadataSyncFramework = this.txtPrefijoMetadata.Text,
esquemaMetadataSyncFramework = this.txtEsquemaMetadata.Text,
prefijoParaNombreDeAmbito = this.txtPrefijoAmbitos.Text,
esquemaQueSeReplica = this.txtEsquemaAReplicar.Text,
HilosParaAprovisionar = Convert.ToInt32(this.txtHilosAprovisionar.Text.ToString()),
HilosParaReplicar = Convert.ToInt32(this.txtHilosReplica.Text.ToString()),
ReplicarSoloAmbitosconCambios = this.chkSoloConCambios.Checked,
SuscribirseATodosLosEventosDeInformacion = this.chkSuscribirseATodos.Checked,
UsarDescripcionLocal = chkUsarDescripcionLocal.Checked,
UsarDescripcionRemota = chkUsarDescripcionRemota.Checked
};
}
public string ObtenerAmbitosSerializados(ParametrosReplica parametros)
{
InicializarVariablesDeSeteoSync(parametros);
//ConectarConSQLServer(parametros.StringConnectionLocal, parametros.StringConnectionRemoto);
var ambitos = ObtenerAmbitosAProcesar(parametros);
return(JsonConvert.SerializeObject(ambitos));
}
public void IniciarReplica(ParametrosReplica parametrosReplica)
{
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
//Inicializa las propiedades de esquemas y prefijos en la clase.
InicializarVariablesDeSeteoSync(parametrosReplica);
//Si se tiene o no configurado el tracing en el app.config, se va a loguear.
LoguearNivelDeTracingConfigurador();
//Conecta con los endpoints
var conexionLocalSql = GetSQLConnection(parametrosReplica.StringConnectionLocal);
var conexionRemotoSql = GetSQLConnection(parametrosReplica.StringConnectionRemoto);
//Crea los esquemas segun corresponda.
ControlarEsquemas(conexionLocalSql, parametrosReplica.esquemaQueSeReplica);
ControlarEsquemas(conexionRemotoSql, parametrosReplica.esquemaQueSeReplica);
//Limpia toda la metadata relacionada a Sync Framework de ambos endpoints segun corresponda.
if (parametrosReplica.LimpiarServidorLocal)
{
DesaprovicionarServidor(conexionLocalSql);
}
if (parametrosReplica.LimpiarServidorRemoto)
{
DesaprovicionarServidor(conexionRemotoSql);
}
//Obtiene los ambitos seleccionados.
List <DbSyncScopeDescription> Ambitos = ObtenerAmbitosAProcesar(parametrosReplica);
//Elimina y crea los ambitos segun corresponda con lo deseado.
MantenerAprovisionamientoDeAmbitosEnHilos(parametrosReplica, _esquemaMetadataSyncFramework, _prefijoMetadataSyncFramework, Ambitos);
_nombreDeBaseRemota = conexionRemotoSql.Database;
//Crea si corresponde la tabla de Anclas.
MantenerTablaDeAnclasLocal(conexionLocalSql);
CloseSQLConnection(conexionLocalSql);
CloseSQLConnection(conexionRemotoSql);
//Inicia proceso de replica
if (parametrosReplica.RealizarReplica)
{
ReplicarAmbitos(Ambitos, parametrosReplica);
}
stopWatch.Stop();
TimeSpan ts = stopWatch.Elapsed;
TiempoTotalTranscurrido = String.Format("{0:00}:{1:00}:{2:00}.{3:00}", ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10);
OnProcesoFinalizado?.Invoke();
}
private void InicializarVariablesDeSeteoSync(ParametrosReplica parametros)
{
_prefijoParaNombreDeAmbito = parametros.prefijoParaNombreDeAmbito;
Loguear("Prefijo para nombre de Ambito: " + _prefijoParaNombreDeAmbito);
_esquemaMetadataSyncFramework = parametros.esquemaMetadataSyncFramework;
Loguear("Esquema para Metadata de Sync Framework: " + _esquemaMetadataSyncFramework);
_prefijoMetadataSyncFramework = parametros.prefijoMetadataSyncFramework;
Loguear("Prefijo para Metadata de Sync Framework: " + _prefijoMetadataSyncFramework);
_esquemaQueSeReplica = parametros.esquemaQueSeReplica;
Loguear("Esquema de la base que se replica: " + parametros.esquemaQueSeReplica);
_suscribirATodosLosEventos = parametros.SuscribirseATodosLosEventosDeInformacion;
}
public void IniciarReplica(ParametrosReplica parametrosReplica)
{
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
//Inicializa las propiedades de esquemas y prefijos en la clase.
this.InicializarVariablesDeSeteoSync(parametrosReplica);
//Si se tiene o no configurado el tracing en el app.config, se va a loguear.
this.loguearNivelDeTracingConfigurador();
//Conecta con los endpoints
this.ConectarConSQLServer(parametrosReplica.StringConnectionLocal, parametrosReplica.StringConnectionRemoto);
//Crea los esquemas segun corresponda.
this.ControlarEsquemas(parametrosReplica.esquemaQueSeReplica);
//Limpia toda la metadata relacionada a Sync Framework de ambos endpoints segun corresponda.
if (parametrosReplica.LimpiarServidorLocal)
{
this.DesaprovicionarServidor(this.conexionLocalSql);
}
if (parametrosReplica.LimpiarServidorRemoto)
{
this.DesaprovicionarServidor(this.conexionRemotoSql);
}
//Obtiene los ambitos seleccionados.
List <DbSyncScopeDescription> Ambitos = this.ObtenerAmbitosAProcesar(parametrosReplica);
//Elimina y crea los ambitos segun corresponda con lo deseado.
this.MantenerAprovisionamientoDeAmbitosEnHilos(parametrosReplica, esquemaMetadataSyncFramework, prefijoMetadataSyncFramework, Ambitos);
this.nombreDeBaseRemota = this.conexionRemotoSql.Database;
this.MantenerTablaDeAnclasLocal();
//Inicia proceso de replica
if (parametrosReplica.RealizarReplica)
{
SyncOrchestrator orchestrator = this.ObtenerOrquestadorDeReplica(parametrosReplica);
this.ReplicarAmbitos(orchestrator, Ambitos, parametrosReplica);
}
stopWatch.Stop();
TimeSpan ts = stopWatch.Elapsed;
this.TiempoTotalTranscurrido = String.Format("{0:00}:{1:00}:{2:00}.{3:00}", ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10);
if (this.onProcesoFinalizado != null)
{
this.onProcesoFinalizado();
}
}
private List <DbSyncScopeDescription> ObtenerAmbitosAProcesar(ParametrosReplica parametros)
{
List <DbSyncScopeDescription> Ambitos = new List <DbSyncScopeDescription>();
foreach (string tabla in parametros.ListaDeTablas)
{
var tablaSplit = tabla.Split('.');
string schema = tablaSplit[0];
string NombreTabla = tablaSplit[1];
var conexionSql = (parametros.SitioDeSubida) ? conexionLocalSql : conexionRemotoSql;
Ambitos.Add(this.CrearAmbito(String.Format(this.prefijoParaNombreDeAmbito, schema, NombreTabla), tabla, conexionSql));
}
return(Ambitos);
}
private void btnIniciar_Click(object sender, EventArgs e)
{
this.lstLogueo.Items.Clear();
this.lstLogueo.Refresh();
this.ManagerSync = new ManagerSyncFramework();
this.ManagerSync.onLoguearVisualmente += this.loguear;
this.ManagerSync.onProcesoFinalizado += this.procesoFinalizado;
this.parametrosReplica = new ParametrosReplica();
this.parametrosReplica.AprovisionarAmbitosEnServidorLocal = this.chkAprovisionarAmbitosEnServidorLocal.Checked;
this.parametrosReplica.AprovisionarAmbitosEnServidorRemoto = this.chkAprovisionarAmbitosEnServidorRemoto.Checked;
this.parametrosReplica.DesaprovisionarAmbitosEnServidorLocal = this.chkDesaprovisionarAmbitosEnServidorLocal.Checked;
this.parametrosReplica.DesaprovisionarAmbitosEnServidorRemoto = this.chkDesaprovisionarAmbitosEnServidorRemoto.Checked;
this.parametrosReplica.LimpiarServidorLocal = this.chkLimpiarServidorLocal.Checked;
this.parametrosReplica.LimpiarServidorRemoto = this.chkLimpiarServidorRemoto.Checked;
this.parametrosReplica.RealizarReplica = this.chkReplicar.Checked;
this.parametrosReplica.StringConnectionLocal = this.txtStringConnectionLocal.Text + ";Application Name=Manager de Sync Framework;";
this.parametrosReplica.StringConnectionRemoto = this.txtStringConnectionRemoto.Text + ";Application Name=Manager de Sync Framework;";
this.parametrosReplica.ListaDeTablas = this.ObtenerListaDeTablas(this.lctChkTablasLocalesAReplicar.CheckedItems);
this.parametrosReplica.SitioDeSubida = this.chkSitioLocalDeSubida.Checked;
this.parametrosReplica.tamañoDeCache = Convert.ToUInt32(this.txtTamañoCache.Text.ToString());
this.parametrosReplica.TamañoDeTransaccion = Convert.ToUInt32(this.txtTamañoTransaccion.Text.ToString());
this.parametrosReplica.TimeOut = Convert.ToInt32(this.txtTimeOut.Text.ToString());
this.parametrosReplica.prefijoMetadataSyncFramework = this.txtPrefijoMetadata.Text; // "Sql_Replica";
this.parametrosReplica.esquemaMetadataSyncFramework = this.txtEsquemaMetadata.Text; // "SyncZooLogic";
this.parametrosReplica.prefijoParaNombreDeAmbito = this.txtPrefijoAmbitos.Text; //"Novedades_[{0}].[{1}]"; //Novedades_[ZooLogic].[ADT_COMB]
this.parametrosReplica.esquemaQueSeReplica = this.txtEsquemaAReplicar.Text;
this.parametrosReplica.HilosParaAprovisionar = Convert.ToInt32(this.txtHilosAprovisionar.Text.ToString());
this.parametrosReplica.HilosParaReplicar = Convert.ToInt32(this.txtHilosReplica.Text.ToString());
this.parametrosReplica.ReplicarSoloAmbitosconCambios = this.chkSoloConCambios.Checked;
this.parametrosReplica.SuscribirseATodosLosEventosDeInformacion = this.chkSuscribirseATodos.Checked;
if (!this.chkSitioLocalDeSubida.Checked && !this.chkSitioLocalDeBajada.Checked)
{
System.Windows.Forms.MessageBox.Show("Debe indicar si el sitio es de subida o bajada.");
return;
}
try
{
this.activarBotones(false);
System.Threading.Thread nuevoHilo = new System.Threading.Thread(this.IniciarReplica);
nuevoHilo.Name = "Replicando manager de sincronización";
nuevoHilo.Start();
}
catch (Exception de)
{
this.loguear(de.ToString());
this.procesoFinalizado();
}
}
private void StartReplicationOfOneScope(ParametrosReplica parameters, DbSyncScopeDescription ambito)
{
IDbConnection conexionLocalSql = null;
IDbConnection conexionRemotoSql = null;
try
{
SyncOrchestrator orchestrator = ObtenerOrquestadorDeReplica(parameters);
conexionLocalSql = GetSQLConnection(parameters.StringConnectionLocal);
conexionRemotoSql = GetSQLConnection(parameters.StringConnectionRemoto);
var proveedorLocal = ObtenerProveedor(ambito.ScopeName, conexionLocalSql, parameters.TamañoDeCache, parameters.TamañoDeTransaccion);
var proveedorRemoto = ObtenerProveedor(ambito.ScopeName, conexionRemotoSql, parameters.TamañoDeCache, parameters.TamañoDeTransaccion);
proveedorLocal.CommandTimeout = parameters.TimeOut;
proveedorRemoto.CommandTimeout = parameters.TimeOut;
orchestrator.LocalProvider = proveedorLocal;
orchestrator.RemoteProvider = proveedorRemoto;
var replicar = true;
int anclaActual = ObtenerAnclaActual(conexionLocalSql);
if (parameters.ReplicarSoloAmbitosconCambios)
{
replicar = ElAmbitoTieneNovedades(ambito, conexionLocalSql);
}
if (replicar)
{
SyncOperationStatistics statsUpload = orchestrator.Synchronize();
LoguearEstadisticas(statsUpload, ambito);
ActualizarAnclaDeSincronizacion(anclaActual, ambito, conexionLocalSql);
}
}
catch (Exception error)
{
Loguear("Error al replicar el ambito: " + ambito.ScopeName + " Error: " + error.ToString());
}
finally
{
CloseSQLConnection(conexionLocalSql);
CloseSQLConnection(conexionRemotoSql);
_replicationSemaphore.Release(1);
}
}
public void IniciarReplica( ParametrosReplica parametrosReplica )
{
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
//Inicializa las propiedades de esquemas y prefijos en la clase.
this.InicializarVariablesDeSeteoSync( parametrosReplica );
//Si se tiene o no configurado el tracing en el app.config, se va a loguear.
this.loguearNivelDeTracingConfigurador();
//Conecta con los endpoints
this.ConectarConSQLServer( parametrosReplica.StringConnectionLocal, parametrosReplica.StringConnectionRemoto );
//Crea los esquemas segun corresponda.
this.ControlarEsquemas( parametrosReplica.esquemaQueSeReplica);
//Limpia toda la metadata relacionada a Sync Framework de ambos endpoints segun corresponda.
if (parametrosReplica.LimpiarServidorLocal) this.DesaprovicionarServidor( this.conexionLocalSql );
if (parametrosReplica.LimpiarServidorRemoto) this.DesaprovicionarServidor( this.conexionRemotoSql );
//Obtiene los ambitos seleccionados.
List<DbSyncScopeDescription> Ambitos = this.ObtenerAmbitosAProcesar(parametrosReplica);
//Elimina y crea los ambitos segun corresponda con lo deseado.
this.MantenerAprovisionamientoDeAmbitosEnHilos(parametrosReplica, esquemaMetadataSyncFramework, prefijoMetadataSyncFramework, Ambitos);
this.nombreDeBaseRemota = this.conexionRemotoSql.Database;
this.MantenerTablaDeAnclasLocal();
//Inicia proceso de replica
if (parametrosReplica.RealizarReplica)
{
SyncOrchestrator orchestrator = this.ObtenerOrquestadorDeReplica(parametrosReplica);
this.ReplicarAmbitos( orchestrator, Ambitos, parametrosReplica);
}
stopWatch.Stop();
TimeSpan ts = stopWatch.Elapsed;
this.TiempoTotalTranscurrido = String.Format("{0:00}:{1:00}:{2:00}.{3:00}", ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10);
if ( this.onProcesoFinalizado != null )
this.onProcesoFinalizado();
}
private SyncOrchestrator ObtenerOrquestadorDeReplica(ParametrosReplica parametros)
{
SyncOrchestrator orchestrator = new SyncOrchestrator();
if (parametros.SitioDeSubida)
{
orchestrator.Direction = SyncDirectionOrder.Upload;
}
else
{
orchestrator.Direction = SyncDirectionOrder.Download;
}
if (_suscribirATodosLosEventos)
{
orchestrator.SessionProgress += new EventHandler <SyncStagedProgressEventArgs>(Orchestrator_SessionProgress);
orchestrator.StateChanged += new EventHandler <SyncOrchestratorStateChangedEventArgs>(Orchestrator_StateChanged);
}
return(orchestrator);
}
private void MantenerAprovisionamientoDeAmbitosEnHilos(ParametrosReplica parametros, string esquemaMetadataSyncFramework, string prefijoMetadataSyncFramework, List <DbSyncScopeDescription> Ambitos)
{
this.semaforo = new Semaphore(parametros.HilosParaAprovisionar, parametros.HilosParaAprovisionar);
this.HilosAprovisionando = 0;
foreach (DbSyncScopeDescription ambito in Ambitos)
{
DbSyncScopeDescription LocalAmbito = ambito;
Thread t = new Thread(delegate()
{
this.MantenerAprovisionamientoDeAmbitos(parametros, esquemaMetadataSyncFramework, prefijoMetadataSyncFramework, LocalAmbito);
});
t.Start();
}
while (this.HilosAprovisionando != 0)
{
Thread.Sleep(500);
}
}
//int timeOut, uint tamañoDeCache)
private void ReplicarAmbitos(SyncOrchestrator orchestrator, List<DbSyncScopeDescription> Ambitos, ParametrosReplica parametrosReplica )
{
foreach (DbSyncScopeDescription ambito in Ambitos)
{
//////////////// PROVEEDORES DE REPLICA (CONOCEN LA LOGICA DEL MOTOR DE DATOS A REPLICAR) ////////////////
SqlSyncProvider proveedorLocal = this.ObtenerProveedor(ambito.ScopeName, conexionLocalSql, parametrosReplica.tamañoDeCache, parametrosReplica.TamañoDeTransaccion);
SqlSyncProvider proveedorRemoto = this.ObtenerProveedor(ambito.ScopeName, conexionRemotoSql, parametrosReplica.tamañoDeCache, parametrosReplica.TamañoDeTransaccion);
proveedorLocal.CommandTimeout = parametrosReplica.TimeOut;
proveedorRemoto.CommandTimeout = parametrosReplica.TimeOut;
orchestrator.LocalProvider = proveedorLocal;
orchestrator.RemoteProvider = proveedorRemoto;
try
{
bool replicar = true;
int anclaActual = this.ObtenerAnclaActual();
if (parametrosReplica.ReplicarSoloAmbitosconCambios)
{
replicar = this.ElAmbitoTieneNovedades( ambito );
}
if (replicar)
{
SyncOperationStatistics statsUpload = orchestrator.Synchronize();
this.loguearEstadisticas(statsUpload, ambito);
this.ActualizarAnclaDeSincronizacion(anclaActual, ambito);
}
}
catch (Exception error)
{
this.loguear("Error al replicar el ambito: " + ambito.ScopeName + " Error: " + error.ToString());
}
}
}
private SyncOrchestrator ObtenerOrquestadorDeReplica(ParametrosReplica parametros)
{
SyncOrchestrator orchestrator = new SyncOrchestrator();
if (parametros.SitioDeSubida)
orchestrator.Direction = SyncDirectionOrder.Upload;
else
orchestrator.Direction = SyncDirectionOrder.Download;
if (this.SuscribirATodosLosEventos)
{
orchestrator.SessionProgress += new EventHandler<SyncStagedProgressEventArgs>(this.orchestrator_SessionProgress);
orchestrator.StateChanged += new EventHandler<SyncOrchestratorStateChangedEventArgs>(this.orchestrator_StateChanged);
}
return orchestrator;
}
private List<DbSyncScopeDescription> ObtenerAmbitosAProcesar(ParametrosReplica parametros )
{
List<DbSyncScopeDescription> Ambitos = new List<DbSyncScopeDescription>();
foreach (string tabla in parametros.ListaDeTablas)
{
var tablaSplit = tabla.Split('.');
string schema = tablaSplit[0];
string NombreTabla = tablaSplit[1];
var conexionSql = (parametros.SitioDeSubida) ? conexionLocalSql : conexionRemotoSql;
Ambitos.Add(this.CrearAmbito(String.Format(this.prefijoParaNombreDeAmbito, schema, NombreTabla), tabla, conexionSql));
}
return Ambitos;
}
private void MantenerAprovisionamientoDeAmbitosEnHilos(ParametrosReplica parametros, string esquemaMetadataSyncFramework, string prefijoMetadataSyncFramework, List<DbSyncScopeDescription> Ambitos)
{
this.semaforo = new Semaphore(parametros.HilosParaAprovisionar, parametros.HilosParaAprovisionar);
this.HilosAprovisionando = 0;
foreach (DbSyncScopeDescription ambito in Ambitos)
{
DbSyncScopeDescription LocalAmbito = ambito;
Thread t = new Thread(delegate()
{
this.MantenerAprovisionamientoDeAmbitos(parametros, esquemaMetadataSyncFramework, prefijoMetadataSyncFramework, LocalAmbito);
});
t.Start();
}
while (this.HilosAprovisionando != 0)
{
Thread.Sleep(500);
}
}
private void MantenerAprovisionamientoDeAmbitos(ParametrosReplica parametros, string esquemaMetadataSyncFramework, string prefijoMetadataSyncFramework, DbSyncScopeDescription ambito)
{
this.semaforo.WaitOne();
this.HilosAprovisionando++;
try
{
SqlConnection NuevaConexionLocalSql = null;
SqlConnection NuevaConexionRemotoSql = null;
SqlSyncScopeProvisioning proveedorDeAmbitoLocal = null;
SqlSyncScopeProvisioning proveedorDeAmbitoRemoto = null;
if (parametros.DesaprovisionarAmbitosEnServidorLocal || parametros.AprovisionarAmbitosEnServidorLocal)
{
try{
NuevaConexionLocalSql = new SqlConnection(parametros.StringConnectionLocal);
NuevaConexionLocalSql.Open();
}
catch (Exception er){
this.loguear("Error al abrir conexión local al crear al aprovisionador!!: " + er.ToString());
}
proveedorDeAmbitoLocal = this.CrearProveedorDeAmbito(esquemaMetadataSyncFramework, prefijoMetadataSyncFramework, NuevaConexionLocalSql, ambito);
proveedorDeAmbitoLocal.CommandTimeout = parametros.TimeOut;
}
if (parametros.DesaprovisionarAmbitosEnServidorRemoto || parametros.AprovisionarAmbitosEnServidorRemoto)
{
try
{
NuevaConexionRemotoSql = new SqlConnection(parametros.StringConnectionRemoto);
NuevaConexionRemotoSql.Open();
}
catch (Exception er)
{
this.loguear("Error al abrir conexión remota al crear al aprovisionador!!: " + er.ToString());
}
proveedorDeAmbitoRemoto = this.CrearProveedorDeAmbito(esquemaMetadataSyncFramework, prefijoMetadataSyncFramework, NuevaConexionRemotoSql, ambito);
proveedorDeAmbitoRemoto.CommandTimeout = parametros.TimeOut;
}
if ( parametros.DesaprovisionarAmbitosEnServidorLocal)
this.DesaprovicionarAmbito(NuevaConexionLocalSql, ambito, proveedorDeAmbitoLocal);
if ( parametros.DesaprovisionarAmbitosEnServidorRemoto)
this.DesaprovicionarAmbito(NuevaConexionRemotoSql, ambito, proveedorDeAmbitoRemoto);
if ( parametros.AprovisionarAmbitosEnServidorLocal )
this.AprovicionarAmbito(ambito, proveedorDeAmbitoLocal);
if ( parametros.AprovisionarAmbitosEnServidorRemoto)
this.AprovicionarAmbito(ambito, proveedorDeAmbitoRemoto);
if (NuevaConexionLocalSql != null && NuevaConexionLocalSql.State == ConnectionState.Open)
NuevaConexionLocalSql.Close();
if (NuevaConexionRemotoSql != null && NuevaConexionRemotoSql.State == ConnectionState.Open)
NuevaConexionRemotoSql.Close();
}
catch (Exception errorcito)
{
this.loguear("Error manteniendo ambitos!!: " + errorcito.ToString());
}
finally
{
this.semaforo.Release(1);
this.HilosAprovisionando--;
}
}
private void InicializarVariablesDeSeteoSync(ParametrosReplica parametros)
{
this.prefijoParaNombreDeAmbito = parametros.prefijoParaNombreDeAmbito;
this.loguear("Prefijo para nombre de Ambito: " + prefijoParaNombreDeAmbito);
this.esquemaMetadataSyncFramework = parametros.esquemaMetadataSyncFramework;
this.loguear("Esquema para Metadata de Sync Framework: " + esquemaMetadataSyncFramework);
this.prefijoMetadataSyncFramework = parametros.prefijoMetadataSyncFramework;
this.loguear("Prefijo para Metadata de Sync Framework: " + prefijoMetadataSyncFramework);
this.esquemaQueSeReplica = parametros.esquemaQueSeReplica;
this.loguear("Esquema de la base que se replica: " + parametros.esquemaQueSeReplica);
this.SuscribirATodosLosEventos = parametros.SuscribirseATodosLosEventosDeInformacion;
}
private void btnIniciar_Click(object sender, EventArgs e)
{
this.lstLogueo.Items.Clear();
this.lstLogueo.Refresh();
this.ManagerSync = new ManagerSyncFramework();
this.ManagerSync.onLoguearVisualmente += this.loguear;
this.ManagerSync.onProcesoFinalizado += this.procesoFinalizado;
this.parametrosReplica = new ParametrosReplica();
this.parametrosReplica.AprovisionarAmbitosEnServidorLocal = this.chkAprovisionarAmbitosEnServidorLocal.Checked;
this.parametrosReplica.AprovisionarAmbitosEnServidorRemoto = this.chkAprovisionarAmbitosEnServidorRemoto.Checked;
this.parametrosReplica.DesaprovisionarAmbitosEnServidorLocal = this.chkDesaprovisionarAmbitosEnServidorLocal.Checked;
this.parametrosReplica.DesaprovisionarAmbitosEnServidorRemoto = this.chkDesaprovisionarAmbitosEnServidorRemoto.Checked;
this.parametrosReplica.LimpiarServidorLocal = this.chkLimpiarServidorLocal.Checked;
this.parametrosReplica.LimpiarServidorRemoto = this.chkLimpiarServidorRemoto.Checked;
this.parametrosReplica.RealizarReplica = this.chkReplicar.Checked;
this.parametrosReplica.StringConnectionLocal = this.txtStringConnectionLocal.Text + ";Application Name=Manager de Sync Framework;";
this.parametrosReplica.StringConnectionRemoto = this.txtStringConnectionRemoto.Text + ";Application Name=Manager de Sync Framework;";
this.parametrosReplica.ListaDeTablas = this.ObtenerListaDeTablas( this.lctChkTablasLocalesAReplicar.CheckedItems );
this.parametrosReplica.SitioDeSubida = this.chkSitioLocalDeSubida.Checked;
this.parametrosReplica.tamañoDeCache = Convert.ToUInt32(this.txtTamañoCache.Text.ToString());
this.parametrosReplica.TamañoDeTransaccion = Convert.ToUInt32(this.txtTamañoTransaccion.Text.ToString());
this.parametrosReplica.TimeOut = Convert.ToInt32( this.txtTimeOut.Text.ToString());
this.parametrosReplica.prefijoMetadataSyncFramework = this.txtPrefijoMetadata.Text; // "Sql_Replica";
this.parametrosReplica.esquemaMetadataSyncFramework = this.txtEsquemaMetadata.Text; // "SyncZooLogic";
this.parametrosReplica.prefijoParaNombreDeAmbito = this.txtPrefijoAmbitos.Text; //"Novedades_[{0}].[{1}]"; //Novedades_[ZooLogic].[ADT_COMB]
this.parametrosReplica.esquemaQueSeReplica = this.txtEsquemaAReplicar.Text;
this.parametrosReplica.HilosParaAprovisionar = Convert.ToInt32( this.txtHilosAprovisionar.Text.ToString() );
this.parametrosReplica.HilosParaReplicar = Convert.ToInt32( this.txtHilosReplica.Text.ToString() );
this.parametrosReplica.ReplicarSoloAmbitosconCambios = this.chkSoloConCambios.Checked;
this.parametrosReplica.SuscribirseATodosLosEventosDeInformacion = this.chkSuscribirseATodos.Checked;
if (!this.chkSitioLocalDeSubida.Checked && !this.chkSitioLocalDeBajada.Checked)
{
System.Windows.Forms.MessageBox.Show("Debe indicar si el sitio es de subida o bajada.");
return;
}
try
{
this.activarBotones(false);
System.Threading.Thread nuevoHilo = new System.Threading.Thread(this.IniciarReplica);
nuevoHilo.Name = "Replicando manager de sincronización";
nuevoHilo.Start();
}
catch (Exception de)
{
this.loguear(de.ToString());
this.procesoFinalizado();
}
}
private void MantenerAprovisionamientoDeAmbitos(ParametrosReplica parametros, string esquemaMetadataSyncFramework, string prefijoMetadataSyncFramework, DbSyncScopeDescription ambito)
{
this.semaforo.WaitOne();
this.HilosAprovisionando++;
try
{
SqlConnection NuevaConexionLocalSql = null;
SqlConnection NuevaConexionRemotoSql = null;
SqlSyncScopeProvisioning proveedorDeAmbitoLocal = null;
SqlSyncScopeProvisioning proveedorDeAmbitoRemoto = null;
if (parametros.DesaprovisionarAmbitosEnServidorLocal || parametros.AprovisionarAmbitosEnServidorLocal)
{
try{
NuevaConexionLocalSql = new SqlConnection(parametros.StringConnectionLocal);
NuevaConexionLocalSql.Open();
}
catch (Exception er) {
this.loguear("Error al abrir conexión local al crear al aprovisionador!!: " + er.ToString());
}
proveedorDeAmbitoLocal = this.CrearProveedorDeAmbito(esquemaMetadataSyncFramework, prefijoMetadataSyncFramework, NuevaConexionLocalSql, ambito);
proveedorDeAmbitoLocal.CommandTimeout = parametros.TimeOut;
}
if (parametros.DesaprovisionarAmbitosEnServidorRemoto || parametros.AprovisionarAmbitosEnServidorRemoto)
{
try
{
NuevaConexionRemotoSql = new SqlConnection(parametros.StringConnectionRemoto);
NuevaConexionRemotoSql.Open();
}
catch (Exception er)
{
this.loguear("Error al abrir conexión remota al crear al aprovisionador!!: " + er.ToString());
}
proveedorDeAmbitoRemoto = this.CrearProveedorDeAmbito(esquemaMetadataSyncFramework, prefijoMetadataSyncFramework, NuevaConexionRemotoSql, ambito);
proveedorDeAmbitoRemoto.CommandTimeout = parametros.TimeOut;
}
if (parametros.DesaprovisionarAmbitosEnServidorLocal)
{
this.DesaprovicionarAmbito(NuevaConexionLocalSql, ambito, proveedorDeAmbitoLocal);
}
if (parametros.DesaprovisionarAmbitosEnServidorRemoto)
{
this.DesaprovicionarAmbito(NuevaConexionRemotoSql, ambito, proveedorDeAmbitoRemoto);
}
if (parametros.AprovisionarAmbitosEnServidorLocal)
{
this.AprovicionarAmbito(ambito, proveedorDeAmbitoLocal);
}
if (parametros.AprovisionarAmbitosEnServidorRemoto)
{
this.AprovicionarAmbito(ambito, proveedorDeAmbitoRemoto);
}
if (NuevaConexionLocalSql != null && NuevaConexionLocalSql.State == ConnectionState.Open)
{
NuevaConexionLocalSql.Close();
}
if (NuevaConexionRemotoSql != null && NuevaConexionRemotoSql.State == ConnectionState.Open)
{
NuevaConexionRemotoSql.Close();
}
}
catch (Exception errorcito)
{
this.loguear("Error manteniendo ambitos!!: " + errorcito.ToString());
}
finally
{
this.semaforo.Release(1);
this.HilosAprovisionando--;
}
}
private void ReplicarAmbitos(SyncOrchestrator orchestrator, List <DbSyncScopeDescription> Ambitos, ParametrosReplica parametrosReplica) //int timeOut, uint tamañoDeCache)
{
foreach (DbSyncScopeDescription ambito in Ambitos)
{
//////////////// PROVEEDORES DE REPLICA (CONOCEN LA LOGICA DEL MOTOR DE DATOS A REPLICAR) ////////////////
SqlSyncProvider proveedorLocal = this.ObtenerProveedor(ambito.ScopeName, conexionLocalSql, parametrosReplica.tamañoDeCache, parametrosReplica.TamañoDeTransaccion);
SqlSyncProvider proveedorRemoto = this.ObtenerProveedor(ambito.ScopeName, conexionRemotoSql, parametrosReplica.tamañoDeCache, parametrosReplica.TamañoDeTransaccion);
proveedorLocal.CommandTimeout = parametrosReplica.TimeOut;
proveedorRemoto.CommandTimeout = parametrosReplica.TimeOut;
orchestrator.LocalProvider = proveedorLocal;
orchestrator.RemoteProvider = proveedorRemoto;
try
{
bool replicar = true;
int anclaActual = this.ObtenerAnclaActual();
if (parametrosReplica.ReplicarSoloAmbitosconCambios)
{
replicar = this.ElAmbitoTieneNovedades(ambito);
}
if (replicar)
{
SyncOperationStatistics statsUpload = orchestrator.Synchronize();
this.loguearEstadisticas(statsUpload, ambito);
this.ActualizarAnclaDeSincronizacion(anclaActual, ambito);
}
}
catch (Exception error)
{
this.loguear("Error al replicar el ambito: " + ambito.ScopeName + " Error: " + error.ToString());
}
}
}
private void MantenerAprovisionamientoDeAmbitos(ParametrosReplica parametros, string esquemaMetadataSyncFramework, string prefijoMetadataSyncFramework, DbSyncScopeDescription ambito)
{
_semaphore.WaitOne();
IDbConnection localSQLConnection = null;
IDbConnection remoteSQLConnection = null;
try
{
SqlSyncScopeProvisioning proveedorDeAmbitoLocal = null;
SqlSyncScopeProvisioning proveedorDeAmbitoRemoto = null;
if (parametros.DesaprovisionarAmbitosEnServidorLocal || parametros.AprovisionarAmbitosEnServidorLocal)
{
localSQLConnection = GetSQLConnection(parametros.StringConnectionLocal);
proveedorDeAmbitoLocal = CrearProveedorDeAmbito(esquemaMetadataSyncFramework, prefijoMetadataSyncFramework, localSQLConnection, ambito);
proveedorDeAmbitoLocal.CommandTimeout = parametros.TimeOut;
}
if (parametros.DesaprovisionarAmbitosEnServidorRemoto || parametros.AprovisionarAmbitosEnServidorRemoto)
{
remoteSQLConnection = GetSQLConnection(parametros.StringConnectionRemoto);
proveedorDeAmbitoRemoto = CrearProveedorDeAmbito(esquemaMetadataSyncFramework, prefijoMetadataSyncFramework, remoteSQLConnection, ambito);
proveedorDeAmbitoRemoto.CommandTimeout = parametros.TimeOut;
}
if (parametros.DesaprovisionarAmbitosEnServidorLocal)
{
DesaprovicionarAmbito(localSQLConnection, ambito, proveedorDeAmbitoLocal);
}
if (parametros.DesaprovisionarAmbitosEnServidorRemoto)
{
DesaprovicionarAmbito(remoteSQLConnection, ambito, proveedorDeAmbitoRemoto);
}
if (parametros.AprovisionarAmbitosEnServidorLocal)
{
AprovicionarAmbito(ambito, proveedorDeAmbitoLocal);
}
if (parametros.AprovisionarAmbitosEnServidorRemoto)
{
AprovicionarAmbito(ambito, proveedorDeAmbitoRemoto);
}
if (localSQLConnection != null && localSQLConnection.State == ConnectionState.Open)
{
localSQLConnection.Close();
}
if (remoteSQLConnection != null && remoteSQLConnection.State == ConnectionState.Open)
{
remoteSQLConnection.Close();
}
}
catch (Exception errorcito)
{
Loguear("Error manteniendo ambitos!!: " + errorcito.ToString());
}
finally
{
CloseSQLConnection(localSQLConnection);
CloseSQLConnection(remoteSQLConnection);
_semaphore.Release(1);
}
}
