public override void Realizar(FileSystem fileSystem)
{
if (fileSystem.Info is FileInfo)
{
string rutaFinal = RutaDestino;
if (rutaFinal[rutaFinal.Length - 1] == '\\')
{
rutaFinal = rutaFinal.Substring(rutaFinal.Length - 2);
}
rutaFinal = string.Format(@"{0}\{1}.zip", rutaFinal, fileSystem.Info.Name.Replace(fileSystem.Info.Extension, ""));
IMonitorArchivo monitor = MonitorArchivoFactory.ObtenerArchivo();
monitor.PrepararDirectorio(rutaFinal);
using (FileStream zipToOpen = new FileStream(rutaFinal, FileMode.OpenOrCreate))
{
using (ZipArchive archive = new ZipArchive(zipToOpen, ZipArchiveMode.Update))
{
archive.CreateEntryFromFile(fileSystem.Info.FullName, fileSystem.Info.Name);
}
}
new Eliminar().Realizar(fileSystem);
}
else
{
throw new Exception("¡No se puede mover un directorio!");
}
}
/// <summary>
/// Obtiene la configuración desde el archivo XML.
/// </summary>
/// <remarks>
/// Registro de versiones:
///
/// 1.0 08/10/2015 Marcos Abraham Hernández Bravo (Ada Ltda.): versión inicial.
/// </remarks>
/// <param name="claseDAO">Tipo de la clase de un DAO.</param>
/// <returns></returns>
public static DynamicQueryRoot ObtenerConfiguracion(Type claseDAO)
{
IMonitorArchivo monitor = MonitorArchivoFactory.ObtenerArchivo();
string DynamicQueryConfigPath = FrameworkConfigurationManager.ObtenerRutaArchivoConfiguracion(CARPETA_DYNAMIC_QUERIES);
string ruta = monitor.ObtenerRutaArchivo(DynamicQueryConfigPath, claseDAO.FullName + ".dbq.xml");
string clave = null;
if (monitor.Existe(ruta))
{
DynamicQueryConfigPath = ruta;
clave = claseDAO.FullName;
}
else
{
DynamicQueryConfigPath = monitor.ObtenerRutaArchivoExistente(DynamicQueryConfigPath, claseDAO.Name + ".dbq.xml");
clave = claseDAO.Name;
}
if ((!ArchivosConsultas.ContainsKey(clave)) || (monitor.FueModificado(ArchivosConsultas[clave].FechaUltimaModificacion, DynamicQueryConfigPath)))
{
XmlSerializer serializer = new XmlSerializer(typeof(DynamicQueryRoot));
FileStream file = null;
DynamicQueryRoot retorno = null;
try
{
file = new FileStream(DynamicQueryConfigPath, FileMode.Open);
retorno = serializer.Deserialize(file) as DynamicQueryRoot;
}
catch (Exception e)
{
throw e;
}
finally
{
if (file != null)
{
file.Close();
}
}
if (retorno != null)
{
Configuracion = retorno;
}
if (!ArchivosConsultas.ContainsKey(clave))
{
ArchivosConsultas.Add(clave, retorno);
}
ArchivosConsultas[clave].FechaUltimaModificacion = monitor.ObtenerFechaUltimaModificacion(DynamicQueryConfigPath);
}
return(Configuracion);
}
public static void Inicializar()
{
if (!Inicializado)
{
Config = new DynamicLoaderConfigManager().ObtenerConfiguracion();
IMonitorArchivo monitor = MonitorArchivoFactory.ObtenerArchivo();
foreach (AppDomainTag appDomainTag in Config.Domains)
{
foreach (AElementsTag elemento in appDomainTag.Elementos)
{
elemento.Ruta = monitor.ObtenerRutaAbsoluta(elemento.Ruta);
if (elemento is DirectoryTag)
{
CargarEnsamblados(appDomainTag.Nombre, elemento.Ruta, (elemento as DirectoryTag).Recursivo);
}
else if (elemento is AssemblyTag)
{
CargarEnsamblado(appDomainTag.Nombre, elemento.Ruta);
}
FileSystemWatcher watcher = new FileSystemWatcher();
watcher.Path = elemento.Ruta;
watcher.NotifyFilter = NotifyFilters.Attributes | NotifyFilters.CreationTime | NotifyFilters.DirectoryName | NotifyFilters.FileName | NotifyFilters.LastWrite | NotifyFilters.Size;
watcher.Filter = "*.dll";
watcher.Changed += new FileSystemEventHandler(OnChanged);
watcher.EnableRaisingEvents = true;
}
}
foreach (AElementsTag elemento in Config.Elementos)
{
elemento.Ruta = monitor.ObtenerRutaAbsoluta(elemento.Ruta);
if (elemento is DirectoryTag)
{
CargarEnsamblados(elemento.Ruta, (elemento as DirectoryTag).Recursivo);
}
else if (elemento is AssemblyTag)
{
AppDomain dominio = CrearDominio(elemento.Ruta);
CargarEnsamblado(dominio, elemento.Ruta);
}
FileSystemWatcher watcher = new FileSystemWatcher();
watcher.Path = elemento.Ruta;
watcher.NotifyFilter = NotifyFilters.Attributes | NotifyFilters.CreationTime | NotifyFilters.DirectoryName | NotifyFilters.FileName | NotifyFilters.LastWrite | NotifyFilters.Size;
watcher.Filter = "*.dll";
watcher.Changed += new FileSystemEventHandler(OnChanged);
watcher.EnableRaisingEvents = true;
}
}
}
static int Main(string[] args)
{
IMonitorArchivo monitor = MonitorArchivoFactory.ObtenerArchivo();
string rutaLogError = monitor.ObtenerRutaAbsoluta(".[DS]Error.log.txt");
try
{
FileSystemManager manager = new FileSystemManager();
AdministradorArchivoTag admin = manager.ObtenerConfiguracion();
foreach (Accion accion in admin.Acciones)
{
foreach (FileSystem fileSystem in FileSystemManager.ObtenerFileSystems(accion))
{
IList <Evaluador <object> > evaluadores = FileSystemManager.ObtenerEvaluadores(admin.Evaluadores);
IList <ExpresionCondicional> condiciones = FileSystemManager.ObtenerCondiciones(accion.Condiciones);
if (EvaluadorExpresiones.EvaluarCondiciones(fileSystem, condiciones, evaluadores))
{
accion.Realizar(fileSystem);
}
}
}
if (monitor.Existe(rutaLogError))
{
new Eliminar().Realizar(new FileSystem()
{
Info = new FileInfo(rutaLogError), Tipo = TipoFileSystem.Archivo
});
}
}
catch (Exception ex)
{
FileStream logError = new FileStream(rutaLogError, FileMode.Create, FileAccess.Write, FileShare.ReadWrite);
StreamWriter writer = new StreamWriter(logError);
writer.AutoFlush = true;
Exception exepcionAux = ex;
while (exepcionAux != null)
{
writer.WriteLine(exepcionAux.Message);
writer.WriteLine("------------------------------------------------------------------------------");
writer.WriteLine(exepcionAux.StackTrace);
writer.WriteLine("\n");
exepcionAux = exepcionAux.InnerException;
}
writer.Close();
logError.Close();
return(1);
}
return(0);
}
/// <summary>
/// Obtiene la implementación para la configuración de la base de datos.
/// </summary>
/// <remarks>
/// Registro de versiones:
///
/// 1.0 02/03/2015 Marcos Abraham Hernández Bravo (Ada Ltda.): versión inicial.
/// </remarks>
/// <returns>Una implementación de <see cref="Ada.Framework.Data.DBConnector.Connections.IConfiguracionBaseDatos"></see>.</returns>
/// <exception cref="Ada.Framework.Data.DBConnector.Connections.Exceptions.ConfiguracionBaseDatosException">Lanzada al no encontrar la declaración de sección en el archivo de configuración.</exception>
/// <exception cref="Ada.Framework.Util.FileMonitor.Exceptions.ArchivoNoEncontradoException">Lanzada al no encontrar el archivo en la ruta especificada por DataBaseConnectionsPath.</exception>
/// <exception cref="Ada.Framework.Util.FileMonitor.Exceptions.ArchivoNoEncontradoException">Lanzada al no encontrar el archivo en la ruta especificada por DataBaseConnectionsValidatorPath.</exception>
public static IConfiguracionBaseDatos ObtenerConfiguracionDeBaseDatos()
{
IMonitorArchivo monitor = MonitorArchivoFactory.ObtenerArchivo();
string DataBaseConnectionsPath = FrameworkConfigurationManager.ObtenerRutaArchivoConfiguracion("DataBaseConnections");
string DataBaseConnectionsValidatorPath = FrameworkConfigurationManager.ObtenerRutaArchivoConfiguracion("DataBaseConnectionsValidator");
DataBaseConnectionsPath = monitor.ObtenerRutaArchivoExistente(DataBaseConnectionsPath, NOMBRE_ARCHIVO_CONEXION);
DataBaseConnectionsValidatorPath = monitor.ObtenerRutaArchivoExistente(DataBaseConnectionsValidatorPath, NOMBRE_ARCHIVO_VALIDADOR_XML_CONEXION);
return(new ConfiguracionBaseDatos(DataBaseConnectionsPath, DataBaseConnectionsValidatorPath));
}
public override void Inicializar()
{
if (file == null)
{
IMonitorArchivo monitor = MonitorArchivoFactory.ObtenerArchivo();
file = new FileStream(monitor.ObtenerRutaAbsoluta(OutputPath), FileMode.OpenOrCreate, FileAccess.Write, FileShare.ReadWrite);
}
if (writer == null)
{
writer = new StreamWriter(file) { AutoFlush = true };
}
}
public static Assembly CargarEnsamblado(string nombreDominio, string rutaEnsamblado)
{
rutaEnsamblado = MonitorArchivoFactory.ObtenerArchivo().ObtenerRutaAbsoluta(rutaEnsamblado);
AppDomain dominio = ObtenerDominio(nombreDominio);
if (dominio != null)
{
return(CargarEnsamblado(dominio, rutaEnsamblado));
}
return(null);
}
public static Assembly ObtenerEnsambladoPorRuta(string rutaEnsamblado)
{
rutaEnsamblado = MonitorArchivoFactory.ObtenerArchivo().ObtenerRutaAbsoluta(rutaEnsamblado);
Assembly[] ensamblados = ObtenerEnsamblados();
if (ensamblados != null)
{
return(ensamblados.FirstOrDefault(c => c.Location.Equals(rutaEnsamblado, StringComparison.InvariantCultureIgnoreCase)));
}
return(null);
}
public string ObtenerRuta(int numeroArchivo)
{
string retorno = FileNameFormat;
string fechaActual = string.Empty;
if (!string.IsNullOrEmpty(DateTimeFormat) && !string.IsNullOrEmpty(DateTimeFormat.Trim()))
{
fechaActual = DateTime.Now.ToString(DateTimeFormat);
}
if (numeroArchivo > 1)
{
if (retorno.Contains("[FileNumber]"))
{
retorno = retorno.Replace("[FileNumber]", numeroArchivo.ToString());
}
else
{
if (retorno.LastIndexOf(".") != -1)
{
retorno = retorno.Substring(0, retorno.LastIndexOf(".")) + numeroArchivo + retorno.Substring(retorno.LastIndexOf("."));
}
else
{
retorno += numeroArchivo;
}
}
}
else
{
retorno = retorno.Replace("[FileNumber]", string.Empty);
}
if (retorno.Contains("[DateTime]"))
{
retorno = retorno.Replace("[DateTime]", fechaActual);
}
IMonitorArchivo monitor = MonitorArchivoFactory.ObtenerArchivo();
if (!Path.EndsWith(monitor.SEPARADOR_CARPETAS))
{
Path += monitor.SEPARADOR_CARPETAS;
}
monitor.PrepararDirectorio(Path);
retorno = monitor.ObtenerRutaAbsoluta(Path + retorno);
return(retorno);
}
public static Assembly CargarEnsamblado(AppDomain dominio, string rutaEnsamblado)
{
rutaEnsamblado = MonitorArchivoFactory.ObtenerArchivo().ObtenerRutaAbsoluta(rutaEnsamblado);
Assembly retorno = ObtenerEnsambladoPorRuta(dominio, rutaEnsamblado);
if (retorno == null)
{
string nombreEnsamblado = Assembly.LoadFrom(rutaEnsamblado).FullName;
retorno = dominio.Load(nombreEnsamblado);
OnLoadAssembly(retorno);
}
return(retorno);
}
public virtual T ObtenerConfiguracion(string rutaReferencial, string ruta)
{
try
{
IMonitorArchivo monitor = MonitorArchivoFactory.ObtenerArchivo();
ruta = monitor.ObtenerRutaAbsoluta(rutaReferencial, ruta);
DateTime fechaUltimaModificacionActual = monitor.ObtenerFechaUltimaModificacion(ruta);
if (fechaUltimaModificacionActual > FechaUltimaModificacion)
{
if (ValidarXmlSchema)
{
ValidarContraXmlSchema();
}
else
{
XmlDocument doc = ObtenerXmlDocument(ruta);
ValidarXml(doc);
}
XmlSerializer serializer = ObtenerXmlSerializer();
FileStream file = null;
try
{
file = ObtenerFileStreamForRead(ruta);
Configuracion = Deserialize(serializer, file);
}
finally
{
if (file != null)
{
file.Close();
}
}
FechaUltimaModificacion = fechaUltimaModificacionActual;
}
return(Configuracion);
}
catch (Exception ex)
{
throw new AdaFrameworkConfigurationException(string.Format("!Error al obtener la configuración de {0}!. {1}", NombreArchivoConfiguracion, ex.Message), ex);
}
}
public override void Realizar(FileSystem fileSystem)
{
if (fileSystem.Info is FileInfo)
{
IMonitorArchivo monitor = MonitorArchivoFactory.ObtenerArchivo();
monitor.PrepararDirectorio(RutaDestino);
if (RutaDestino[RutaDestino.Length - 1] != '\\')
{
RutaDestino += "\\";
}
(fileSystem.Info as FileInfo).MoveTo(RutaDestino + fileSystem.Info.Name);
}
else
{
throw new Exception("¡No se puede mover un directorio!");
}
}
/// <summary>
/// Obtiene el serializador XML para el archivo de configuración. Carga los ensamblados de los escritores de Log4Me.
/// </summary>
/// <remarks>
/// Registro de versiones:
///
/// 1.0 10/04/2016 Marcos Abraham Hernández Bravo (Ada Ltda.): versión inicial.
/// </remarks>
/// <returns></returns>
protected override XmlSerializer ObtenerXmlSerializer()
{
XmlAttributeOverrides xOver = new XmlAttributeOverrides();
XmlAttributes xAttrs = new XmlAttributes();
List <Assembly> ensamblados = new List <Assembly>();
Assembly assembly = null;
string ruta = FrameworkConfigurationManager.ObtenerValorPropiedad <string>("Log4Me", "LibrariesFolderWriters");
ruta = MonitorArchivoFactory.ObtenerArchivo().ObtenerRutaAbsoluta(ruta);
string[] archivos = Directory.GetFiles(ruta, "*.dll");
foreach (string archivo in archivos)
{
if (Path.GetFileName(archivo).StartsWith("Log4Me.", StringComparison.InvariantCultureIgnoreCase))
{
assembly = Assembly.LoadFile(archivo);
ensamblados.Add(assembly);
}
}
var tipos = (from lAssembly in ensamblados
from tipo in lAssembly.GetTypes()
where typeof(ALogWriter).IsAssignableFrom(tipo)
where !tipo.IsAbstract
select tipo).ToArray();
foreach (var tipo in tipos)
{
xAttrs.XmlArrayItems.Add(new XmlArrayItemAttribute(tipo));
}
xOver.Add(typeof(Log4MeConfig), "Writers", xAttrs);
return(new XmlSerializer(typeof(Log4MeConfig), xOver));
}
public virtual void GuardarConfiguracion(T config, string rutaReferencial, string ruta)
{
IMonitorArchivo monitor = MonitorArchivoFactory.ObtenerArchivo();
ruta = monitor.ObtenerRutaAbsoluta(rutaReferencial, ruta);
FileStream file = null;
try
{
XmlSerializer serializer = ObtenerXmlSerializer();
file = ObtenerFileStreamForWrite(ruta);
Serialize(serializer, file, config);
}
finally
{
if (file != null)
{
file.Close();
}
}
}
private static void OnChanged(object source, FileSystemEventArgs e)
{
IMonitorArchivo monitor = MonitorArchivoFactory.ObtenerArchivo();
switch (e.ChangeType)
{
case WatcherChangeTypes.Created:
AppDomain dominio = CrearDominio(e.FullPath);
CargarEnsamblado(dominio, e.FullPath);
break;
case WatcherChangeTypes.Deleted:
DescargarEnsambladoPorRuta(e.FullPath);
break;
case WatcherChangeTypes.Changed:
RecargarEnsamblado(e.FullPath);
break;
case WatcherChangeTypes.Renamed:
break;
}
}
/// <summary>
/// Carga la configuración desde el archivo XML a memoria. De paso lo valida.
/// </summary>
/// <remarks>
/// Registro de versiones:
///
/// 1.0 02/03/2015 Marcos Abraham Hernández Bravo (Ada Ltda.): versión inicial.
/// </remarks>
/// <exception cref="Ada.Framework.Util.FileMonitor.Exceptions.ArchivoNoEncontradoException">Lanzado al no encontrar el archivo XML o su esquema.</exception>
/// <exception cref="Ada.Framework.Data.DBConnector.Connections.Exceptions.ConfiguracionBaseDatosException">Lanzado al encontrar al archivo de configuración inválido.</exception>
public void CargarConfiguracion(bool comprobarFechaModificacion = false)
{
IMonitorArchivo monitor = MonitorArchivoFactory.ObtenerArchivo();
if (monitor.Existe(DataBaseConnectionsPath))
{
if (!fechaUltimaModificacionArchivo.HasValue)
{
fechaUltimaModificacionArchivo = new DateTime(1, 1, 1);
}
if (!comprobarFechaModificacion || (Conexiones == null || Conexiones.Count == 0 || monitor.FueModificado(fechaUltimaModificacionArchivo.Value, DataBaseConnectionsPath)))
{
Conexiones = new List <ConexionTO>();
Conectores = new List <ConectorTO>();
XmlDocument doc;
XmlReader reader = null;
try
{
CargarXML(out doc, out reader);
foreach (XmlNode appender in doc.DocumentElement.ChildNodes[1].ChildNodes)
{
if (appender is XmlElement)
{
XmlElement element = (appender as XmlElement);
Conectores.Add(new ConectorTO()
{
Name = element.GetAttribute("Name"),
Instance = element.GetAttribute("Instance"),
AssemblyName = element.GetAttribute("AssemblyName"),
AssemblyPath = element.GetAttribute("AssemblyPath")
});
}
}
foreach (XmlNode elemento in doc.DocumentElement.ChildNodes[0].ChildNodes)
{
if (elemento is XmlElement)
{
XmlElement element = (elemento as XmlElement);
ConectorTO conector = Conectores.Where(c => c.Name == element.GetAttribute("Type")).First();
Conexiones.Add(new ConexionTO()
{
ConnectionString = element.GetAttribute("ConnectionString"),
Name = element.GetAttribute("Name"),
Instance = conector.Instance,
Type = element.GetAttribute("Type"),
AssemblyName = conector.AssemblyName,
AssemblyPath = conector.AssemblyPath
});
}
}
}
finally
{
if (reader != null)
{
reader.Close();
}
}
}
fechaUltimaModificacionArchivo = monitor.ObtenerFechaUltimaModificacion(DataBaseConnectionsPath);
}
else
{
throw new ArchivoNoEncontradoException("¡No se ha encontrado el archivo de conexiones a bases de datos!", DataBaseConnectionsPath);
}
}
public override void Inicializar()
{
IMonitorArchivo monitor = MonitorArchivoFactory.ObtenerArchivo();
if (NumeroArchivo == 0)
{
NumeroArchivo = 1;
}
if (Rolling.By.Equals("Date", StringComparison.InvariantCultureIgnoreCase))
{
if (Rolling.Unit.Equals("Day", StringComparison.InvariantCultureIgnoreCase))
{
checked
{
if (FechaUltimoArchivoCreado.AddDays((int)Rolling.Value) >= DateTime.Now)
{
FechaUltimoArchivoCreado = DateTime.Now;
NumeroArchivo++;
}
}
}
else if (Rolling.Unit.Equals("Week", StringComparison.InvariantCultureIgnoreCase))
{
checked
{
int diferenciaDias = (int)Rolling.Value;
diferenciaDias *= 7;
if (FechaUltimoArchivoCreado.AddDays(diferenciaDias) >= DateTime.Now)
{
FechaUltimoArchivoCreado = DateTime.Now;
NumeroArchivo++;
}
}
}
else if (Rolling.Unit.Equals("Month", StringComparison.InvariantCultureIgnoreCase))
{
checked
{
if (FechaUltimoArchivoCreado.AddMonths((int)Rolling.Value) >= DateTime.Now)
{
FechaUltimoArchivoCreado = DateTime.Now;
NumeroArchivo++;
}
}
}
else if (Rolling.Unit.Equals("Year", StringComparison.InvariantCultureIgnoreCase))
{
checked
{
if (FechaUltimoArchivoCreado.AddYears((int)Rolling.Value) >= DateTime.Now)
{
FechaUltimoArchivoCreado = DateTime.Now;
NumeroArchivo++;
}
}
}
}
else if (Rolling.By.Equals("Size", StringComparison.InvariantCultureIgnoreCase))
{
if (monitor.Existe(RutaActualArchivo))
{
//Tamaño en MB.
double tamañoArchivo = (new FileInfo(RutaActualArchivo).Length / 1048576.0);
double tamañoLimite = Rolling.Value;
if (Rolling.Unit.Equals("GB", StringComparison.InvariantCultureIgnoreCase))
{
tamañoLimite *= 1024;
}
if (Rolling.Unit.Equals("MB", StringComparison.InvariantCultureIgnoreCase) ||
Rolling.Unit.Equals("GB", StringComparison.InvariantCultureIgnoreCase))
{
if (tamañoArchivo > tamañoLimite)
{
FechaUltimoArchivoCreado = DateTime.Now;
NumeroArchivo++;
}
}
}
}
string ruta = Output.ObtenerRuta(NumeroArchivo);
if (RutaActualArchivo != ruta)
{
file = new FileStream(ruta, FileMode.Append, FileAccess.Write, FileShare.ReadWrite);
writer = new StreamWriter(file)
{
AutoFlush = true
};
}
RutaActualArchivo = ruta;
}
