public AdvancedViewModel(ILumiaSettingsService lumiaSettingsService, IFileSystemOperations fileSystemOperations,
UIServices uiServices, IDeploymentContext context, IOperationContext operationContext, IOperationProgress progress,
IList <Meta <IDiskLayoutPreparer> > diskPreparers,
ILogCollector logCollector)
{
this.lumiaSettingsService = lumiaSettingsService;
this.uiServices = uiServices;
this.context = context;
this.logCollector = logCollector;
DiskPreparers = diskPreparers;
DeleteDownloadedWrapper = new ProgressViewModel(ReactiveCommand.CreateFromTask(() => DeleteDownloaded(fileSystemOperations)), progress, this, uiServices.ContextDialog, operationContext);
ForceDualBootWrapper = new ProgressViewModel(ReactiveCommand.CreateFromTask(ForceDualBoot), progress, this, uiServices.ContextDialog, operationContext);
ForceSingleBootWrapper = new ProgressViewModel(ReactiveCommand.CreateFromTask(ForceDisableDualBoot), progress, this, uiServices.ContextDialog, operationContext);
CollectLogsCommmandWrapper = new ProgressViewModel(ReactiveCommand.CreateFromTask(CollectLogs), progress, this, uiServices.ContextDialog, operationContext);
IsBusyObservable = Observable.Merge(DeleteDownloadedWrapper.Command.IsExecuting,
ForceDualBootWrapper.Command.IsExecuting, ForceSingleBootWrapper.Command.IsExecuting,
CollectLogsCommmandWrapper.Command.IsExecuting);
preparerUpdater = this.WhenAnyValue(x => x.SelectedPreparer)
.Where(x => x != null)
.Subscribe(x =>
{
context.DiskLayoutPreparer = x.Value;
lumiaSettingsService.DiskPreparer = (string)x.Metadata["Name"];
});
SelectedPreparer = GetInitialDiskPreparer();
}
/// <summary>
/// Creates a logger with given collector
/// </summary>
/// <param name="collector">Ultimate destination of log messages</param>
/// <returns></returns>
public static ILog GetLogger(ILogCollector collector)
{
ILog ret = InstantiateLogger();
ret.Collector = collector;
return(ret);
}
/// <summary>
/// Initializes the FFDA logger with given Syslog facility and concrete logger
/// </summary>
/// <param name="facility">Syslog facility that will be used for all the messages</param>
/// <param name="target">Concrete logger that will collect FFDA messages</param>
/// <param name="loggerName">Name of logger</param>
public FieldFailureDataLogger(SyslogFacility facility, ILogCollector target, string loggerName)
: base(facility, target)
{
LogName = loggerName;
Log("SUP", SyslogSeverity.Info);
}
/// <summary>
/// Initializes LogCollectorTie with a target object
/// </summary>
/// <param name="target">Object to proxy</param>
/// <exception cref="System.ArgumentNullException">Argument is null</exception>
public LogCollectorTie(ILogCollector target)
{
if (target == null)
{
throw new ArgumentNullException("target");
}
Target = target;
}
/// <summary>
/// Creates a logger with given facility and collector
/// </summary>
/// <param name="facility">Syslog facility to use</param>
/// <param name="collector">Ultimate destination of log messages</param>
/// <returns></returns>
public static ILog GetLogger(SyslogFacility facility, ILogCollector collector)
{
ILogger ret = InstantiateLogger();
ret.Collector = collector;
ret.Facility = facility;
return(ret);
}
static void Main(string[] args)
{
Console.CancelKeyPress += Console_CancelKeyPress;
if (args == null || args.Length < 1)
{
Console.WriteLine("Usage: NoiseSource ([MESSAGE_RATE]|\"inf\")");
Console.WriteLine();
Console.WriteLine();
Console.WriteLine("\tMESSAGE_RATE:\t number of messages sent per second");
Console.WriteLine();
Console.WriteLine();
Console.WriteLine("Example: \tNoiseSource 1500");
Console.WriteLine("sends 1500 messages per second");
Console.WriteLine("\tNoiseSource inf");
Console.WriteLine("sends infinite messages, flooding network socket");
Environment.Exit(0);
}
int rate = 0;
if (args[0] != "inf" && !int.TryParse(args[0], out rate) || rate == 0)
{
Console.WriteLine("Invalid rate");
Environment.Exit(1);
}
long timeout = 10000000 / rate; //100ns timeout
if (timeout == 0)
{
Console.WriteLine("Ready to send infinite messages at infinite rate");
}
else
{
Console.WriteLine("Ready to send infinite messages at a rate of {0}/s", rate);
}
ILogCollector server = CollectorHelper.CreateCollector();
string host = System.Net.Dns.GetHostName();
while (true)
{
SyslogMessage startMsg = new SyslogMessage
{
Timestamp = DateTime.Now,
Facility = SyslogFacility.Printer,
Severity = SyslogSeverity.Debug,
Host = host,
MessageId = "NOISE",
Text = "The quick brown fox jumps over the lazy dog"
};
server.SubmitMessage(startMsg);
if (rate > 0)
{
Thread.Sleep(new TimeSpan(timeout));
}
}
}
public void CreateDefaultCollectorTest()
{
ILogCollector expected = null; // TODO: Eseguire l'inizializzazione a un valore appropriato
ILogCollector actual;
actual = CollectorHelper.CreateCollector();
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Verificare la correttezza del metodo di test.");
}
/// <summary>
/// Constructor with facility and collector
/// </summary>
/// <param name="facility">Syslog facility</param>
/// <param name="target">Ultimate destination of messages</param>
public SimpleLogImpl(SyslogFacility facility, ILogCollector target)
: this(facility)
{
if (target == null)
{
throw new ArgumentNullException("target");
}
Collector = target;
}
public void CreateUdpCollectorTest()
{
IPAddress logbus_ip = null; // TODO: Eseguire l'inizializzazione a un valore appropriato
int logbus_port = 0; // TODO: Eseguire l'inizializzazione a un valore appropriato
ILogCollector expected = null; // TODO: Eseguire l'inizializzazione a un valore appropriato
ILogCollector actual;
actual = CollectorHelper.CreateUnreliableCollector(logbus_ip, logbus_port);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Verificare la correttezza del metodo di test.");
}
protected override void Awake()
{
base.Awake();
Log.SetLogger(new LoggerImpl());
Container.BindSingleton <ILogCollectionService, LogCollectionService>();
Container.BindSingleton <ILogCallbackRegistrar, DefaultLogCallbackRegistrar>();
if (File.Exists(LogFilePath))
{
File.Delete(LogFilePath);
}
var logCollector = new LogCollector();
logCollector.LogFilePath = LogFilePath;
m_LogCollector = logCollector;
}
public AdvancedViewModel(IRaspberryPiSettingsService raspberryPiSettingsService, IFileSystemOperations fileSystemOperations,
UIServices uiServices, IDeploymentContext context, IOperationContext operationContext,
ILogCollector logCollector)
{
this.raspberryPiSettingsService = raspberryPiSettingsService;
this.uiServices = uiServices;
this.context = context;
this.logCollector = logCollector;
DeleteDownloadedWrapper = new CommandWrapper <Unit, Unit>(this,
ReactiveCommand.CreateFromTask(() => DeleteDownloaded(fileSystemOperations)), uiServices.ContextDialog, operationContext);
CollectLogsCommmandWrapper = new CommandWrapper <Unit, Unit>(this, ReactiveCommand.CreateFromTask(CollectLogs), uiServices.ContextDialog, operationContext);
IsBusyObservable = Observable.Merge(DeleteDownloadedWrapper.Command.IsExecuting,
CollectLogsCommmandWrapper.Command.IsExecuting);
}
public void RemoveLogCollector(ILogCollector collector)
{
if (collector == null)
{
throw new ArgumentNullException("collector");
}
if (m_ReceivingLog)
{
m_Commands.Enqueue(new Cmd {
CmdType = CmdType.Remove, Collector = collector
});
}
else
{
m_LogCollectors.Remove(collector);
}
}
public void AddLogCollector(ILogCollector collector)
{
if (collector == null)
{
throw new ArgumentNullException(nameof(collector));
}
if (m_ReceivingLog)
{
m_Commands.Enqueue(new Cmd {
CmdType = CmdType.Add, Collector = collector
});
}
else
{
m_LogCollectors.Add(collector);
}
}
/// <summary>
/// Creates collector from configuration definition
/// </summary>
/// <param name="def">Configuration entry of collector</param>
/// <returns></returns>
internal static ILogCollector CreateCollector(LogCollectorDefinitionBase def)
{
if (def == null)
{
throw new ArgumentNullException("def");
}
if (string.IsNullOrEmpty(def.type))
{
throw new ArgumentException("Configuration entry doesn't specified required collector type", "def");
}
try
{
string typename = def.type;
if (typename.IndexOf('.') < 0)
{
//This is probably a plain class name, overriding to It.Unina.Dis.Logbus.InChannels namespace
const string namespc = "It.Unina.Dis.Logbus.Collectors";
string assemblyname = typeof(CollectorHelper).Assembly.GetName().ToString();
typename = string.Format("{0}.{1}, {2}", namespc, typename, assemblyname);
}
Type loggerType = Type.GetType(typename);
if (!typeof(ILogCollector).IsAssignableFrom(loggerType))
{
LogbusConfigurationException ex =
new LogbusConfigurationException("Registered collector type does not implement ILogCollector");
ex.Data.Add("type", loggerType);
throw ex;
}
ILogCollector ret = Activator.CreateInstance(loggerType) as ILogCollector;
if (def.param != null && ret is IConfigurable)
{
foreach (KeyValuePair kvp in def.param)
{
((IConfigurable)ret).SetConfigurationParameter(kvp.name, kvp.value);
}
}
return(ret);
}
catch (Exception ex)
{
throw new LogbusConfigurationException("Invalid collector configuration", ex);
}
}
/// <summary>
/// Initializes the FFDA logger with the concrete underlying logger
/// </summary>
/// <param name="target">Concrete logger that will collect FFDA messages</param>
/// <param name="loggerName">Name of logger</param>
public FieldFailureDataLogger(ILogCollector target, string loggerName)
: this(SyslogFacility.Local0, target, loggerName)
{
}
/// <summary>
/// Constructor with collector
/// </summary>
/// <param name="target">Ultimate destination of messages</param>
public SimpleLogImpl(ILogCollector target)
: this(SyslogFacility.Local4, target)
{
}
public LogController(ILogCollector logCollector)
{
_logCollector = logCollector;
}
public FieldFailureAlerter(ILogCollector target)
: base(target)
{
}
private static void Run(int timeout)
{
_messagesRcvd = new BitArray(_expected, false);
_received = 0;
string pid = Process.GetCurrentProcess().Id.ToString(CultureInfo.InvariantCulture);
ILogCollector server = CollectorHelper.CreateCollector();
string host = Dns.GetHostName();
PropertyFilter hostFilter = new PropertyFilter
{
comparison = ComparisonOperator.eq,
value = host,
propertyName = Property.Host
};
FacilityEqualsFilter facFilter = new FacilityEqualsFilter {
facility = SyslogFacility.Local4
};
PropertyFilter pidFilter = new PropertyFilter
{
comparison = ComparisonOperator.eq,
value = pid,
propertyName = Property.ProcessID
};
PropertyFilter idFilter = new PropertyFilter
{
value = "BENCH",
comparison = ComparisonOperator.eq,
propertyName = Property.MessageID
};
SeverityFilter sevFilter = new SeverityFilter
{
comparison = ComparisonOperator.eq,
severity = SyslogSeverity.Notice
};
using (ILogClient client = ClientHelper.CreateReliableClient(hostFilter & pidFilter & idFilter & sevFilter & facFilter))
{
client.MessageReceived += client_MessageReceived;
client.Start();
for (int i = 0; i < _expected; i++)
{
if (timeout > 0)
{
Nanosleep(timeout);
}
SyslogMessage message = new SyslogMessage
{
Timestamp = DateTime.Now,
Facility = SyslogFacility.Local4,
Severity = SyslogSeverity.Notice,
Host = host,
ProcessID = pid,
MessageId = "BENCH",
Text = i.ToString()
};
server.SubmitMessage(message);
}
silenceTimer = new Timer(state => Stop.Set(), null, 40000, Timeout.Infinite);
Console.WriteLine("Waiting up to 30 seconds after last message received...");
Stop.WaitOne();
}
if (_expected == _received)
{
Console.WriteLine("Received all messaged");
}
else
{
Console.WriteLine("Lost {0} messages", _expected - _received);
}
}
/// <summary>
/// Initializes the FFDA logger with the concrete underlying logger
/// </summary>
/// <param name="target">Concrete logger that will collect FFDA messages</param>
public FieldFailureDataLogger(ILogCollector target)
: this(SyslogFacility.Local0, target)
{
}
static void Main(string[] args)
{
bool reliable = args != null && args.Length > 0 && args[0] == "--reliable";
Console.CancelKeyPress += Console_CancelKeyPress;
Console.WriteLine("This program periodically measures the RTT for log messages sent by here");
if (!reliable)
{
Console.WriteLine("Going in unreliable mode. Messages are subject to loss.");
Console.WriteLine("Use the --reliable switch to go into reliable mode, where messages don't get lost.");
}
else
{
Console.WriteLine("Reliable mode activated. No messages will be lost because of the network.");
}
PropertyFilter hostFilter = new PropertyFilter
{
comparison = ComparisonOperator.eq,
value = Dns.GetHostName(),
propertyName = Property.Host
};
PropertyFilter pidFilter = new PropertyFilter
{
comparison = ComparisonOperator.eq,
value =
Process.GetCurrentProcess().Id.ToString(CultureInfo.InvariantCulture),
propertyName = Property.ProcessID
};
PropertyFilter idFilter = new PropertyFilter
{
value = "RTT",
comparison = ComparisonOperator.eq,
propertyName = Property.MessageID
};
_target = CollectorHelper.CreateCollector((reliable) ? "tls" : "udp");
FilterBase filter = hostFilter & pidFilter & idFilter;
_source = (reliable) ? ClientHelper.CreateReliableClient(filter) : ClientHelper.CreateUnreliableClient(filter);
_log = LoggerHelper.GetLogger("Logfile");
_source.MessageReceived += source_MessageReceived;
_source.Start();
while (true)
{
_id++;
DateTime curTimestamp = DateTime.UtcNow;
double millis = (curTimestamp - DateTime.Today).TotalMilliseconds;
string text = _id.ToString(CultureInfo.InvariantCulture) + "_" + millis.ToString(CultureInfo.InvariantCulture);
SyslogMessage message = new SyslogMessage(SyslogFacility.Local3, SyslogSeverity.Notice, text)
{
MessageId = "RTT"
};
_target.SubmitMessage(message);
if (!_ar.WaitOne(10000))
{
Console.WriteLine("RTT sent at {0} lost", curTimestamp);
_log.Warning("RTT sent at {0} lost", curTimestamp);
continue;
}
Thread.Sleep(3000);
}
}
