internal virtual ILogBus CreateILogBus()
{
// TODO: creare l'istanza di una classe concreta appropriata.
LogbusService target = new LogbusService();
LogbusServerConfiguration config = new LogbusServerConfiguration()
{
corefilter = new FacilityEqualsFilter()
{
facility = SyslogFacility.Security
},
inchannels = new InboundChannelDefinition[]
{
new InboundChannelDefinition()
{
type = "It.Unina.Dis.Logbus.InChannels.SyslogUdpReceiver, It.Unina.Dis.Logbus"
}
}
};
target.Configuration = config;
target.Configure();
return(target);
}
public void StartTest()
{
WindowsIdentity identity = WindowsIdentity.GetCurrent();
WindowsPrincipal principal = new WindowsPrincipal(identity);
if (!principal.IsInRole(WindowsBuiltInRole.Administrator))
{
Assert.Fail("You must be running this test as an Administrator");
}
LogbusServerConfiguration config = new LogbusServerConfiguration();
using (ILogBus service = new LogbusService(config))
{
service.Start();
int httpPort = 8065; // TODO: Eseguire l'inizializzazione a un valore appropriato
using (WebServiceActivator webService = new WebServiceActivator(service, httpPort))
{
webService.Start();
Thread.Sleep(10000);
webService.Stop();
}
service.Stop();
}
}
public void Init()
{
try
{
core_configuration = new LogbusServerConfiguration[2];
{
core_configuration[0] = new LogbusServerConfiguration();
//Only messages from Audit
core_configuration[0].corefilter = new FacilityEqualsFilter()
{
facility = SyslogFacility.Audit
};
//Listening on UDP 3140 port
core_configuration[0].inchannels = new InboundChannelDefinition[1];
KeyValuePair[] prm = new KeyValuePair[1];
prm[0] = new KeyValuePair()
{
name = "port",
value = t1_source_port.ToString()
};
core_configuration[0].inchannels[0] = new InboundChannelDefinition()
{
type = "It.Unina.Dis.Logbus.InChannels.SyslogUdpReceiver, It.Unina.Dis.Logbus",
param = prm
};
}
{
core_configuration[1] = new LogbusServerConfiguration();
core_configuration[1].inchannels = new InboundChannelDefinition[1];
KeyValuePair[] prm = new KeyValuePair[1];
prm[0] = new KeyValuePair()
{
name = "port",
value = t2_source_port.ToString()
};
core_configuration[1].inchannels[0] = new InboundChannelDefinition()
{
type = "It.Unina.Dis.Logbus.InChannels.SyslogUdpReceiver, It.Unina.Dis.Logbus",
param = prm
};
}
TestContext.WriteLine("Core configuration is rendered by the following markup");
using (MemoryStream ms = new MemoryStream())
{
new XmlSerializer(core_configuration[0].GetType()).Serialize(ms, core_configuration[0], core_configuration[0].xmlns);
ms.Flush();
ms.Seek(0, SeekOrigin.Begin);
TestContext.WriteLine(Encoding.Default.GetString(ms.ToArray()));
}
TestContext.WriteLine("");
}
catch (Exception ex) { Assert.Fail("Test failed: {0}", ex); }
}
public void TestDeployAsmx()
{
try
{
LogbusServerConfiguration config = new LogbusServerConfiguration();
config.webserver = new WebServerConfiguration {
active = true
};
PluginDefinition plugDef = new PluginDefinition()
{
type = typeof(DummyPlugin).AssemblyQualifiedName
};
config.plugins = new PluginDefinition[] { plugDef };
using (LogbusService logbus = new LogbusService())
{
logbus.Configure(config);
logbus.Start();
//Test HTTP request
DummyStub stub = new DummyStub()
{
Url = "http://localhost:8065/Dummy.asmx"
};
Assert.AreEqual <int>(5, stub.Sum(3, 2));
}
}
catch (Exception ex)
{
Assert.Fail("Test failed: {0}", ex.ToString());
}
}
static void Main(string[] args)
{
object section = ConfigurationManager.GetSection("logbus-source");
Console.WriteLine("Trying to retrieve \"logbus\" section from App.config: {0}", (section is LogbusServerConfiguration) ? "success" : "fail");
if (section is LogbusServerConfiguration)
{
//OK, configuration was loaded;
LogbusServerConfiguration config = (LogbusServerConfiguration)section;
Console.WriteLine("Parsing core filter");
if (config.corefilter == null)
{
Console.WriteLine("Core filter is not specified (always true)");
}
else
{
Console.WriteLine("Root filter is {0}", config.corefilter.GetType().FullName);
}
Console.WriteLine("Core filter parsing end");
Console.WriteLine();
Console.WriteLine("Parsing Inbound channels");
foreach (InboundChannelDefinition inch in config.inchannels)
{
Console.WriteLine("Defined inbound channel of type {0}", inch.type);
foreach (KeyValuePair param in inch.param)
{
Console.WriteLine("Defined parameter {0}={1}", param.name, param.value);
}
}
Console.WriteLine("Inbound channels end");
Console.WriteLine();
Console.WriteLine("Parsing outbound transports");
if (config.outtransports != null)
{
Console.WriteLine("Factory is {0}", config.outtransports.factory);
foreach (OutputTransportDefinition def in config.outtransports.outtransport)
{
Console.WriteLine("Transport factory {0}", def.factory);
}
foreach (AssemblyToScan ass in config.outtransports.scanassembly)
{
Console.WriteLine("Will scan assembly {0} in {1}", ass.assembly, (string.IsNullOrEmpty(ass.codebase)) ? "default paths" : ass.codebase);
}
}
}
else
{
Console.WriteLine("Sorry, pal");
}
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
public void MyTestInitialize()
{
LogbusServerConfiguration coreConfig = new LogbusServerConfiguration
{
inchannels = new[]
{
new InboundChannelDefinition {
type = "SyslogTlsReceiver"
}
},
webserver = new WebServerConfiguration {
active = true
}
};
ConfigurationHelper.ServerConfiguration = coreConfig;
LogbusClientConfiguration clientConfig = new LogbusClientConfiguration
{
endpoint = new LogbusEndpointDefinition {
basePath = "http://localhost:8065/", suffix = ".asmx"
}
};
ConfigurationHelper.ClientConfiguration = clientConfig;
LogbusLoggerConfiguration loggerConfig = new LogbusLoggerConfiguration
{
collector = new[]
{
new LogbusCollectorDefinition
{
id = "tls", type = "SyslogTlsCollector",
param =
new[] { new KeyValuePair {
name = "host", value = "localhost"
} }
}
},
defaultcollector = "tls"
};
ConfigurationHelper.SourceConfiguration = loggerConfig;
}
public void ConfigureTest()
{
LogbusServerConfiguration config = new LogbusServerConfiguration();
config.corefilter = new FacilityEqualsFilter()
{
facility = SyslogFacility.Kernel
};
config.inchannels = new InboundChannelDefinition[]
{
new InboundChannelDefinition()
{
type = "It.Unina.Dis.Logbus.InChannels.SyslogUdpReceiver, It.Unina.Dis.Logbus"
}
};
//Manual configuration
using (ILogBus target = new LogbusService(config))
{
Assert.AreEqual(1, target.InboundChannels.Count);
Assert.IsInstanceOfType(target.MainFilter, typeof(FacilityEqualsFilter));
}
}
public void LogbusTest()
{
step1 = new AutoResetEvent(false);
step2 = new AutoResetEvent(false);
finish = new AutoResetEvent(false);
try
{
LogbusServerConfiguration config = new LogbusServerConfiguration();
config.inchannels = new InboundChannelDefinition[1];
config.inchannels[0] = new InboundChannelDefinition();
config.inchannels[0].type = "It.Unina.Dis.Logbus.InChannels.SyslogUdpReceiver, It.Unina.Dis.Logbus";
config.inchannels[0].param = new KeyValuePair[1];
config.inchannels[0].param[0] =
new KeyValuePair()
{
name = "port",
value = SOURCE_PORT.ToString()
};
using (ILogBus service = new LogbusService(config))
{
service.Start();
new Thread(thread_Client).Start(service);
step1.WaitOne();
new Thread(thread_Source).Start();
step2.WaitOne();
finish.WaitOne();
}
}
catch (Exception ex)
{
Assert.Fail("Test failed: {0}", ex);
}
}
public TLSTest()
{
//
// TODO: aggiungere qui la logica del costruttore
//
core_config = new LogbusServerConfiguration();
core_config.corefilter = new TrueFilter();
core_config.inchannels = new InboundChannelDefinition[1];
core_config.inchannels[0] = new InboundChannelDefinition
{
type = "SyslogTlsReceiver"
};
core_config.inchannels[0].param = new KeyValuePair[1];
core_config.inchannels[0].param[0] = new KeyValuePair {
name = "certificate", value = @"C:\\logbus.p12"
};
source_config = new LogbusLoggerConfiguration();
source_config.logger = new LoggerDefinition[1];
source_config.logger[0] = new LoggerDefinition
{
type = "SyslogTlsCollector",
name = "tls",
};
source_config.logger[0].param = new KeyValuePair[] {
new KeyValuePair()
{
name = "host", value = "localhost"
}
};
ConfigurationHelper.ServerConfiguration = core_config;
ConfigurationHelper.SourceConfiguration = source_config;
}
public void FFDATest()
{
FilterBase ffda_filter =
new FacilityEqualsFilter()
{
facility = SyslogFacility.Local0
} &
new PropertyFilter()
{
comparison = ComparisonOperator.eq, propertyName = Property.MessageID, value = "FFDA"
};
StringBuilder markup = new StringBuilder();
new XmlSerializer(typeof(FilterBase)).Serialize(XmlTextWriter.Create(markup, new XmlWriterSettings()
{
Indent = true
}), ffda_filter, ffda_filter.xmlns);
TestContext.WriteLine("{0}", markup.ToString());
const int SEND_PORT = 5427;
//Init Logbus
LogbusServerConfiguration core_config = new LogbusServerConfiguration();
core_config.corefilter = ffda_filter;
InboundChannelDefinition in_ch = new InboundChannelDefinition();
in_ch.type = "SyslogUdpReceiver";
in_ch.param = new KeyValuePair[]
{
new KeyValuePair()
{
name = "port",
value = SEND_PORT.ToString()
}
};
core_config.inchannels = new InboundChannelDefinition[] { in_ch };
using (ILogBus logbus = new LogbusService(core_config))
{
logbus.MessageReceived += new EventHandler <SyslogMessageEventArgs>(logbus_MessageReceived);
logbus.Start();
//Init FFDA
LogbusLoggerConfiguration source_config = new LogbusLoggerConfiguration();
LoggerDefinition udp_def = new LoggerDefinition()
{
type = "SyslogUdpCollector",
param = new KeyValuePair[] { new KeyValuePair()
{
name = "port", value = SEND_PORT.ToString()
}, new KeyValuePair()
{
name = "ip", value = "127.0.0.1"
} }
};
source_config.logger = new LoggerDefinition[] { udp_def };
LoggerHelper.Configuration = source_config;
//Send what we want: 2 FFDA messages
IFieldFailureDataLogger logger = FieldFailureDataHelper.CreateFailureDataLogger("ffda");
logger.LogSST();
logger.LogSEN();
//Send junk
ILog junk_log = LoggerHelper.GetLogger();
junk_log.Debug("Hello");
junk_log.Error("Junk error");
Thread.Sleep(1000);
logbus.Stop();
}
Assert.AreEqual(2, messages);
}
