public void EventWithPayloadAndEnumsInXml()
{
string fileName = "LogUsingPayloadWithEnumsInProc";
File.Delete(fileName);
var formatter = new XmlEventTextFormatter(EventTextFormatting.Indented, "d");
var logger = MockEventSourceInProcEnum.Logger;
using (var listener = new ObservableEventListener())
{
listener.EnableEvents(logger, EventLevel.LogAlways, Keywords.All);
listener.LogToFlatFile(fileName, formatter);
try
{
logger.SendEnumsEvent16(MockEventSourceInProcEnum.MyColor.Green, MockEventSourceInProcEnum.MyFlags.Flag1);
}
finally
{
listener.DisableEvents(logger);
}
}
var rawOutput = FlatFileHelper.GetAllText(fileName);
var entries = XDocument.Parse("<Events>" + rawOutput + "</Events>").Root.Elements();
Assert.AreEqual(1, entries.Count());
XmlFormattedEntry.Fill(entries.First());
Assert.AreEqual("a", XmlFormattedEntry.Payload.Elements().First().Attribute("Name").Value);
Assert.AreEqual("2", XmlFormattedEntry.Payload.Elements().First().Value);
Assert.AreEqual("b", XmlFormattedEntry.Payload.Elements().Last().Attribute("Name").Value);
Assert.AreEqual("1", XmlFormattedEntry.Payload.Elements().Last().Value);
}
static void MultipleEventListenersLevel()
{
// Set up and enable the event listeners - typically done when the application starts
var listener1 = new ObservableEventListener();
var listener2 = new ObservableEventListener();
listener1.EnableEvents(MyCompanyEventSource.Log, EventLevel.Error, Keywords.All);
listener2.EnableEvents(MyCompanyEventSource.Log, EventLevel.LogAlways, Keywords.All);
listener1.LogToConsole();
var subscription = listener2.LogToFlatFile(@"C:\Temp\DemoSemanticLogging.log", new EventTextFormatter("===================", "==================="));
// Log some messages
MyCompanyEventSource.Log.Startup();
MyCompanyEventSource.Log.Failure("Couldn't connect to server.");
Console.WriteLine("Written two log messages.\nUsing a basic console listener and a Flat File listener to capture them.");
Console.WriteLine("Only the critical message appears in the console, both appear in: \nC:\\Temp\\DemoSemanticLogging.log.\n");
// Flush the sink
subscription.Sink.FlushAsync().Wait();
// Disable the event listener - typically done when the application terminates
listener1.DisableEvents(MyCompanyEventSource.Log);
listener2.DisableEvents(MyCompanyEventSource.Log);
listener1.Dispose();
listener2.Dispose();
}
public void WhenExceptionOccursInCustomFormatter()
{
string fileName = "FlatFileInProcCustomFormatterHandleException.log";
File.Delete(fileName);
var logger = TestEventSourceNonTransient.Logger;
using (var listener = new ObservableEventListener())
using (var collectErrorsListener = new InMemoryEventListener(true))
{
try
{
collectErrorsListener.EnableEvents(SemanticLoggingEventSource.Log, System.Diagnostics.Tracing.EventLevel.Error, Keywords.All);
listener.LogToFlatFile(fileName, new MockFormatter(true));
listener.EnableEvents(logger, System.Diagnostics.Tracing.EventLevel.LogAlways);
logger.EventWithPayload("payload1", 100);
StringAssert.Contains(collectErrorsListener.ToString(), "Payload : [message : System.InvalidOperationException: Operation is not valid due to the current state of the object.");
}
finally
{
listener.DisableEvents(logger);
collectErrorsListener.DisableEvents(SemanticLoggingEventSource.Log);
}
}
}
/// <summary>
/// Creates an event listener that logs using a <see cref="FlatFileSink"/>.
/// </summary>
/// <param name="fileName">Name of the file.</param>
/// <param name="formatter">The formatter.</param>
/// <param name="isAsync">Specifies if the writing should be done asynchronously, or synchronously with a blocking call.</param>
/// <returns>An event listener that uses <see cref="FlatFileSink"/> to log events.</returns>
public static EventListener CreateListener(string fileName = null, IEventTextFormatter formatter = null, bool isAsync = false)
{
var listener = new ObservableEventListener();
listener.LogToFlatFile(fileName, formatter, isAsync);
return(listener);
}
public void WhenUsingCustomFormatter()
{
string fileName = "FlatFileInProcCustomFormatter.log";
File.Delete(fileName);
string header = "----------";
var logger = TestEventSourceNonTransient.Logger;
var formatter = new CustomFormatterWithWait(header);
formatter.Detailed = System.Diagnostics.Tracing.EventLevel.LogAlways;
IEnumerable <string> entries = null;
using (var listener = new ObservableEventListener())
{
try
{
listener.LogToFlatFile(fileName, formatter);
listener.EnableEvents(logger, System.Diagnostics.Tracing.EventLevel.LogAlways);
logger.EventWithPayload("payload1", 100);
entries = FlatFileHelper.PollUntilTextEventsAreWritten(fileName, 1, header);
}
finally
{
listener.DisableEvents(logger);
}
}
StringAssert.Contains(entries.First(), "Mock SourceId");
StringAssert.Contains(entries.First(), "Mock EventId");
StringAssert.Contains(entries.First(), "Payload : [payload1 : payload1] [payload2 : 100]");
}
public override bool OnStart()
{
digest_event_log_listener.EnableEvents(Log, EventLevel.LogAlways,
AzureDigestEventSource.Keywords.Perf | AzureDigestEventSource.Keywords.Diagnostic);
EventTextFormatter formatter = new EventTextFormatter()
{
VerbosityThreshold = EventLevel.Error
};
digest_event_log_listener.LogToFlatFile("Overlord.Digest.Azure.log", formatter, true);
storage_event_log_listener.EnableEvents(AzureStorageEventSource.Log, EventLevel.LogAlways,
AzureStorageEventSource.Keywords.Perf | AzureStorageEventSource.Keywords.Diagnostic);
storage_event_log_listener.LogToFlatFile("Overlord.Storage.Azure.log", formatter, true);
// Set the maximum number of concurrent connections
jss.Converters.Add(new GuidConverter());
ServicePointManager.DefaultConnectionLimit = 12;
// For information on handling configuration changes
// see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
bool result = base.OnStart();
Trace.TraceInformation("Overlord.Digest.Azure has been started");
return(result);
}
public void WhenExceptinOccursInCustomFormater1()
{
string filename = "customFormatterException.log";
File.Delete(filename);
var logger = MockEventSource.Logger;
var formatter = new CustomFormatter(true);
using (var listener = new ObservableEventListener())
using (var collectErrorsListener = new InMemoryEventListener(true))
{
try
{
collectErrorsListener.EnableEvents(SemanticLoggingEventSource.Log, System.Diagnostics.Tracing.EventLevel.LogAlways, Keywords.All);
listener.LogToFlatFile(filename, formatter);
listener.EnableEvents(logger, System.Diagnostics.Tracing.EventLevel.LogAlways, Keywords.All);
logger.LogSomeMessage("testing");
collectErrorsListener.WaitEvents.Wait(3000);
StringAssert.Contains(collectErrorsListener.ToString(), "unhandled exception from formatter");
}
finally
{
listener.DisableEvents(logger);
collectErrorsListener.DisableEvents(SemanticLoggingEventSource.Log);
}
}
}
public static SinkSubscription <FlatFileSink> CreateSink(EventSource eventSource, string path)
{
ObservableEventListener _listener = new ObservableEventListener();
_listener.EnableEvents(eventSource, EventLevel.LogAlways, Keywords.All);
return(_listener.LogToFlatFile(path));
}
public void LogFailure2LogToFlatFileTest()
{
string _filePath = $"{nameof(LogFailure2LogToFlatFileTest)}.log";
FileInfo _logFile = new FileInfo(_filePath);
if (_logFile.Exists)
{
_logFile.Delete();
}
MessageHandlerFactory _factory = new MessageHandlerFactory();
ObservableEventListener _listener = new ObservableEventListener();
UDPMessageHandlerSemanticEventSource _log = UDPMessageHandlerSemanticEventSource.Log;
_listener.EnableEvents(_log, EventLevel.LogAlways, Keywords.All);
SinkSubscription <FlatFileSink> _FlatFileSink = _listener.LogToFlatFile(_filePath);
_logFile.Refresh();
Assert.IsTrue(_logFile.Exists);
Assert.AreEqual <long>(0, _logFile.Length);
_log.Failure(nameof(UDPMessageHandlerSemanticEventSourceUnitTest), nameof(LogFailure2LogToFlatFileTest), "LogFailure");
_FlatFileSink.Sink.FlushAsync();
_logFile.Refresh();
Assert.IsTrue(_logFile.Length > 100);
_FlatFileSink.Dispose();
}
public FileSemanticTracing()
{
FindViableFilePath();
ObservableEventListener listener = new ObservableEventListener();
listener.EnableEvents(SemanticLoggingEventSource.Log, EventLevel.LogAlways, Keywords.All);
_subscription = listener.LogToFlatFile(FilePath);
}
private static void RegisterEFLogger()
{
var listener = new ObservableEventListener();
listener.EnableEvents(EFLogging.Logger, EventLevel.LogAlways, Keywords.All);
listener.LogToFlatFile("EFSqls.log");
listener.LogToWindowsAzureTable(instanceName: "Protiviti", connectionString: "UseDevelopmentStorage=true",tableAddress:"EFSqls");
}
private static void RegisterLogger()
{
var listener = new ObservableEventListener();
listener.EnableEvents(WebApiTracing.Log, EventLevel.LogAlways, Keywords.All);
listener.LogToConsole();
listener.LogToFlatFile("test.log");
listener.LogToWindowsAzureTable(instanceName: "Protiviti", connectionString: "UseDevelopmentStorage=true");
}
protected override void OnStartup(object sender, System.Windows.StartupEventArgs e)
{
logListener = new ObservableEventListener();
logListener.EnableEvents(TivoProxyEventSource.Log, EventLevel.LogAlways, Keywords.All);
logListener.LogToConsole(new SimpleEventTextFormatter());
logListener.LogToFlatFile("ProxyLog.txt", new SimpleEventTextFormatter());
DisplayRootViewFor <IShell>();
}
private void ConfigureLogging()
{
eventListener = new ObservableEventListener();
eventListener.EnableEvents(SparkEngineEventSource.Log, EventLevel.LogAlways,
Keywords.All);
eventListener.EnableEvents(SparkMongoEventSource.Log, EventLevel.LogAlways,
Keywords.All);
eventListener.EnableEvents(SemanticLoggingEventSource.Log, EventLevel.LogAlways, Keywords.All);
var formatter = new JsonEventTextFormatter(EventTextFormatting.Indented);
eventListener.LogToFlatFile(@"C:\projects\fhir\log\spark.log", formatter);
}
public AzureStorageIngestTests()
{
EventTextFormatter formatter = new EventTextFormatter()
{
VerbosityThreshold = EventLevel.Error
};
storage_event_log_listener.EnableEvents(AzureStorageEventSource.Log, EventLevel.LogAlways,
AzureStorageEventSource.Keywords.Perf | AzureStorageEventSource.Keywords.Diagnostic);
storage_event_log_listener.LogToFlatFile("Overlord.Storage.Azure.log", formatter, true);
}
public void WhenMultipleCustomSinksSubscribing()
{
string fileName1 = "mockFlatFileMutiple.log";
File.Delete(fileName1);
string fileName2 = "flatFileMultiple.log";
File.Delete(fileName2);
var validConnectionString = System.Configuration.ConfigurationManager.ConnectionStrings["valid"].ConnectionString;
DatabaseHelper.CleanLoggingDB(validConnectionString);
var logger = MockEventSource.Logger;
string message = string.Concat("Message ", Guid.NewGuid());
string message2 = string.Concat("Message2 ", Guid.NewGuid());
IEnumerable <string> entries = null;
IEnumerable <string> entries2 = null;
using (var eventListener = new ObservableEventListener())
{
try
{
eventListener.LogToMockFlatFile(fileName1, "==-==");
eventListener.LogToFlatFile(fileName2, new EventTextFormatter("--==--"));
eventListener.LogToSqlDatabase("testInstance", validConnectionString, "Traces", TimeSpan.Zero, 1);
eventListener.LogToCustomSqlDatabase("testCustom", validConnectionString);
eventListener.EnableEvents(logger, System.Diagnostics.Tracing.EventLevel.LogAlways, Keywords.All);
logger.LogSomeMessage(message);
logger.LogSomeMessage(message2);
entries = FlatFileHelper.PollUntilTextEventsAreWritten(fileName1, 2, "==-==");
entries2 = FlatFileHelper.PollUntilTextEventsAreWritten(fileName2, 2, "--==--");
}
finally
{
eventListener.DisableEvents(logger);
}
}
Assert.IsTrue(File.Exists(fileName1));
Assert.AreEqual <int>(2, entries.Count());
StringAssert.Contains(entries.First().ToString(), message);
StringAssert.Contains(entries.Last().ToString(), message2);
Assert.IsTrue(File.Exists(fileName2));
Assert.AreEqual <int>(2, entries.Count());
StringAssert.Contains(entries.First().ToString(), message);
StringAssert.Contains(entries.Last().ToString(), message2);
var dt = DatabaseHelper.GetLoggedTable(validConnectionString);
Assert.AreEqual(4, dt.Rows.Count);
}
private void ConfigureLogging()
{
eventListener = new ObservableEventListener();
eventListener.EnableEvents(SparkEngineEventSource.Log, EventLevel.LogAlways,
Keywords.All);
eventListener.EnableEvents(SparkMongoEventSource.Log, EventLevel.LogAlways,
Keywords.All);
eventListener.EnableEvents(SemanticLoggingEventSource.Log, EventLevel.LogAlways, Keywords.All);
var formatter = new JsonEventTextFormatter(EventTextFormatting.Indented);
eventListener.LogToFlatFile(@"C:\projects\fhir\log\spark.log", formatter);
}
protected void Application_Start()
{
var listener = new ObservableEventListener();
listener.EnableEvents(WebApiTracing.Log, EventLevel.LogAlways, Keywords.All);
listener.LogToFlatFile("test.log");
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
}
public static void Configure()
{
var formatter = new EventTextFormatter()
{
VerbosityThreshold = EventLevel.Error
};
ObservableEventListener http_event_log_listener = new ObservableEventListener();
http_event_log_listener.EnableEvents(HttpEventSource.Log, EventLevel.LogAlways,
HttpEventSource.Keywords.Perf | HttpEventSource.Keywords.Diagnostic);
http_event_log_listener.LogToFlatFile("Overlord.Http.log", formatter, true);
}
public static void Configure()
{
List<EventSource> eventSources = new List<EventSource>(new[] { DomainEventSource.Log });
ObservableEventListener logListner = new ObservableEventListener();
foreach (var eventSource in eventSources)
{
logListner.EnableEvents(eventSource, EventLevel.Error , Keywords.All);
}
logListner.LogToFlatFile("log.txt");
}
public static void RegisterLoggingSources(IEnumerable <EventSource> logSources, ISiteSettings settings)
{
var logListener = new ObservableEventListener();
foreach (var logSource in logSources)
{
logListener.EnableEvents(
logSource, EventLevel.LogAlways, Keywords.All);
}
logListener.LogToFlatFile(
fileName: settings.LogFilePath,
formatter: new EventTextFormatter());
}
public static void RegisterLoggingSources(IEnumerable<EventSource> logSources, ISiteSettings settings)
{
var logListener = new ObservableEventListener();
foreach (var logSource in logSources)
{
logListener.EnableEvents(
logSource, EventLevel.LogAlways, Keywords.All);
}
logListener.LogToFlatFile(
fileName: settings.LogFilePath,
formatter: new EventTextFormatter());
}
public static void Configure()
{
List<EventSource> eventSources = new List<EventSource>() { DomainEventSource.Log, SiteEventSource.Log };
ObservableEventListener logListener = new ObservableEventListener();
foreach (var eventSource in eventSources)
{
logListener.EnableEvents(eventSource, EventLevel.LogAlways, Keywords.All);
}
logListener.LogToFlatFile("./Log.txt");
}
public static void Configure()
{
List <EventSource> eventSources = new List <EventSource>()
{
DomainEventSource.Log, SiteEventSource.Log
};
ObservableEventListener logListener = new ObservableEventListener();
foreach (var eventSource in eventSources)
{
logListener.EnableEvents(eventSource, EventLevel.LogAlways, Keywords.All);
}
logListener.LogToFlatFile("./Log.txt");
}
static Api()
{
var formatter = new EventTextFormatter()
{
VerbosityThreshold = EventLevel.Error
};
ObservableEventListener api_event_log_listener = new ObservableEventListener();
api_event_log_listener.EnableEvents(ApiEventSource.Log, EventLevel.LogAlways,
ApiEventSource.Keywords.Perf | ApiEventSource.Keywords.Diagnostic);
api_event_log_listener.LogToFlatFile("Overlord.Core.Api.log", formatter, true);
ObservableEventListener storage_event_log_listener = new ObservableEventListener();
storage_event_log_listener.EnableEvents(AzureStorageEventSource.Log, EventLevel.LogAlways,
AzureStorageEventSource.Keywords.Perf | AzureStorageEventSource.Keywords.Diagnostic);
storage_event_log_listener.LogToFlatFile("Overlord.Storage.Azure.log", formatter, true);
}
public void WhenDriveDoesNotExist()
{
string filepath = string.Empty;
string[] strDrives = Directory.GetLogicalDrives();
string strAlphabets = "A B C D E F G H I J K L M N O P Q R S T U V W X Y Z";
string[] alphabet = strAlphabets.Split(' ');
foreach (string noDriveExists in alphabet)
{
bool notExists = strDrives.Contains(noDriveExists + ":\\");
if (!notExists)
{
// Drive does not exist
filepath = noDriveExists + ":\\";
break;
}
}
var fileName = filepath + "newflatfileDriveNotExists.log";
var formatter = new EventTextFormatter(EventTextFormatter.DashSeparator);
try
{
using (var listener = new ObservableEventListener())
{
listener.LogToFlatFile(fileName, formatter);
}
}
catch (DirectoryNotFoundException ex)
{
StringAssert.StartsWith(ex.Message, "Could not find a part of the path '" + filepath);
}
}
public void WhenFilePathLengthExceedsMaxExceptionOccursEarly()
{
try
{
var folderName = "a";
string completePath = string.Empty;
int countLength = Directory.GetCurrentDirectory().Length;
int folderNameLength = 246 - countLength;
for (int l = 1; l < folderNameLength; l++)
{
folderName = folderName + "a";
}
completePath = DeleteFolder(folderName);
Directory.CreateDirectory(completePath);
var fileName = "longpath.log";
var folderfilePath = completePath + "\\" + fileName;
var formatter = new EventTextFormatter(EventTextFormatter.DashSeparator);
using (var listener = new ObservableEventListener())
{
listener.LogToFlatFile(folderfilePath, formatter);
}
Assert.IsFalse(File.Exists(folderfilePath));
}
catch (PathTooLongException ex)
{
Assert.AreEqual(ex.Message, "The specified path, file name, or both are too long. The fully qualified file name must be less than 260 characters, and the directory name must be less than 248 characters.");
}
}
/// <summary>
/// Creates an event listener that logs using a <see cref="FlatFileSink"/>.
/// </summary>
/// <param name="fileName">Name of the file.</param>
/// <param name="formatter">The formatter.</param>
/// <param name="isAsync">Specifies if the writing should be done asynchronously, or synchronously with a blocking call.</param>
/// <returns>An event listener that uses <see cref="FlatFileSink"/> to log events.</returns>
public static EventListener CreateListener(string fileName = null, IEventTextFormatter formatter = null, bool isAsync = false)
{
var listener = new ObservableEventListener();
listener.LogToFlatFile(fileName, formatter, isAsync);
return listener;
}
public void EventWithPayloadAndEnumsInXml()
{
string fileName = "LogUsingPayloadWithEnumsInProc";
File.Delete(fileName);
var formatter = new XmlEventTextFormatter(EventTextFormatting.Indented, "d");
var logger = MockEventSourceInProcEnum.Logger;
using (var listener = new ObservableEventListener())
{
listener.EnableEvents(logger, EventLevel.LogAlways, Keywords.All);
listener.LogToFlatFile(fileName, formatter);
try
{
logger.SendEnumsEvent16(MockEventSourceInProcEnum.MyColor.Green, MockEventSourceInProcEnum.MyFlags.Flag1);
}
finally
{
listener.DisableEvents(logger);
}
}
var rawOutput = FlatFileHelper.GetAllText(fileName);
var entries = XDocument.Parse("<Events>" + rawOutput + "</Events>").Root.Elements();
Assert.AreEqual(1, entries.Count());
XmlFormattedEntry.Fill(entries.First());
Assert.AreEqual("a", XmlFormattedEntry.Payload.Elements().First().Attribute("Name").Value);
Assert.AreEqual("2", XmlFormattedEntry.Payload.Elements().First().Value);
Assert.AreEqual("b", XmlFormattedEntry.Payload.Elements().Last().Attribute("Name").Value);
Assert.AreEqual("1", XmlFormattedEntry.Payload.Elements().Last().Value);
}
static void MultipleEventListenersLevel()
{
// Set up and enable the event listeners - typically done when the application starts
var listener1 = new ObservableEventListener();
var listener2 = new ObservableEventListener();
listener1.EnableEvents(MyCompanyEventSource.Log, EventLevel.Error, Keywords.All);
listener2.EnableEvents(MyCompanyEventSource.Log, EventLevel.LogAlways, Keywords.All);
listener1.LogToConsole();
var subscription = listener2.LogToFlatFile(@"C:\Temp\DemoSemanticLogging.log", new EventTextFormatter("===================", "==================="));
// Log some messages
MyCompanyEventSource.Log.Startup();
MyCompanyEventSource.Log.Failure("Couldn't connect to server.");
Console.WriteLine("Written two log messages.\nUsing a basic console listener and a Flat File listener to capture them.");
Console.WriteLine("Only the critical message appears in the console, both appear in: \nC:\\Temp\\DemoSemanticLogging.log.\n");
// Flush the sink
subscription.Sink.FlushAsync().Wait();
// Disable the event listener - typically done when the application terminates
listener1.DisableEvents(MyCompanyEventSource.Log);
listener2.DisableEvents(MyCompanyEventSource.Log);
listener1.Dispose();
listener2.Dispose();
}
static void Main(string[] args)
{
eventListener = new ObservableEventListener();
eventListener.LogToFlatFile("Trace.log");
eventListener.EnableEvents(DefaultEventSource.Log, EventLevel.Warning);
string tableConnectionString = ConfigurationManager.AppSettings["StorageConnectionString"];
if (CommandLine.Parser.Default.ParseArgumentsStrict(args, options))
{
string connectionString = ConfigurationManager.ConnectionStrings["Microsoft.ServiceBus.ConnectionString"].ConnectionString;
string taskHubName = ConfigurationManager.AppSettings["TaskHubName"];
IOrchestrationServiceInstanceStore instanceStore = new AzureTableInstanceStore(taskHubName, tableConnectionString);
ServiceBusOrchestrationServiceSettings settings = new ServiceBusOrchestrationServiceSettings
{
TaskOrchestrationDispatcherSettings =
{
CompressOrchestrationState = bool.Parse(ConfigurationManager.AppSettings["CompressOrchestrationState"]),
MaxConcurrentOrchestrations = int.Parse(ConfigurationManager.AppSettings["MaxConcurrentOrchestrations"])
},
TaskActivityDispatcherSettings =
{
MaxConcurrentActivities = int.Parse(ConfigurationManager.AppSettings["MaxConcurrentActivities"])
}
};
ServiceBusOrchestrationService orchestrationServiceAndClient =
new ServiceBusOrchestrationService(connectionString, taskHubName, instanceStore, null, settings);
TaskHubClient taskHubClient = new TaskHubClient(orchestrationServiceAndClient);
TaskHubWorker taskHub = new TaskHubWorker(orchestrationServiceAndClient);
if (options.CreateHub)
{
orchestrationServiceAndClient.CreateIfNotExistsAsync().Wait();
}
OrchestrationInstance instance = null;
string instanceId = options.StartInstance;
if (!string.IsNullOrWhiteSpace(instanceId))
{
var driverConfig = new DriverOrchestrationData
{
NumberOfIteration = int.Parse(ConfigurationManager.AppSettings["DriverOrchestrationIterations"]),
NumberOfParallelTasks = int.Parse(ConfigurationManager.AppSettings["DriverOrchestrationParallelTasks"]),
SubOrchestrationData = new TestOrchestrationData
{
NumberOfParallelTasks = int.Parse(ConfigurationManager.AppSettings["ChildOrchestrationParallelTasks"]),
NumberOfSerialTasks = int.Parse(ConfigurationManager.AppSettings["ChildOrchestrationSerialTasks"]),
MaxDelayInMinutes = int.Parse(ConfigurationManager.AppSettings["TestTaskMaxDelayInMinutes"]),
}
};
instance = taskHubClient.CreateOrchestrationInstanceAsync(typeof(DriverOrchestration), instanceId, driverConfig).Result;
}
else
{
instance = new OrchestrationInstance {
InstanceId = options.InstanceId
};
}
Console.WriteLine($"Orchestration starting: {DateTime.Now}");
Stopwatch stopWatch = Stopwatch.StartNew();
TestTask testTask = new TestTask();
taskHub.AddTaskActivities(testTask);
taskHub.AddTaskOrchestrations(typeof(DriverOrchestration));
taskHub.AddTaskOrchestrations(typeof(TestOrchestration));
taskHub.StartAsync().Wait();
int testTimeoutInSeconds = int.Parse(ConfigurationManager.AppSettings["TestTimeoutInSeconds"]);
OrchestrationState state = WaitForInstance(taskHubClient, instance, testTimeoutInSeconds);
stopWatch.Stop();
Console.WriteLine($"Orchestration Status: {state.OrchestrationStatus}");
Console.WriteLine($"Orchestration Result: {state.Output}");
Console.WriteLine($"Counter: {testTask.counter}");
TimeSpan totalTime = stopWatch.Elapsed;
string elapsedTime = $"{totalTime.Hours:00}:{totalTime.Minutes:00}:{totalTime.Seconds:00}.{totalTime.Milliseconds/10:00}";
Console.WriteLine($"Total Time: {elapsedTime}");
Console.ReadLine();
taskHub.StopAsync().Wait();
}
}
public void ThrowOnDirectoryNotFound()
{
listener.LogToFlatFile(@"Z:\Foo\foo.log");
}
public void WhenFileNameIsNull()
{
try
{
var formatter = new EventTextFormatter(EventTextFormatter.DashSeparator);
using (var listener = new ObservableEventListener())
{
listener.LogToFlatFile(null, formatter);
}
}
catch (ArgumentNullException ex)
{
Assert.AreEqual("Value cannot be null.\r\nParameter name: fileName", ex.Message);
}
}
public void WhenFileNameIsEmpty()
{
try
{
var formatter = new EventTextFormatter(EventTextFormatter.DashSeparator);
using (var listener = new ObservableEventListener())
{
listener.LogToFlatFile(string.Empty, formatter);
}
}
catch (ArgumentException ex)
{
Assert.AreEqual("Argument is empty\r\nParameter name: fileName", ex.Message);
}
}
public void WhenFileNameIsFolder()
{
try
{
var formatter = new EventTextFormatter(EventTextFormatter.DashSeparator);
using (var listener = new ObservableEventListener())
{
listener.LogToFlatFile(".", formatter);
}
}
catch (ArgumentException ex)
{
Assert.AreEqual("A file name with a relative path is not allowed. Provide only the file name or the full path of the file.", ex.Message);
}
}
public void WhenInvalidCharactersInFileName1()
{
try
{
var formatter = new EventTextFormatter(EventTextFormatter.DashSeparator);
using (var listener = new ObservableEventListener())
{
listener.LogToFlatFile(@"|", formatter);
}
}
catch (ArgumentException ex)
{
Assert.AreEqual("Illegal characters in path.", ex.Message);
}
}
public void WhenFileIsReadOnlyErrorOccursDuringEarly()
{
string fileName = "newflatfileReadOnly1.log";
DeleteReadOnlyFile(fileName);
File.Create(fileName);
File.SetAttributes(fileName, FileAttributes.ReadOnly);
string path = Directory.GetCurrentDirectory();
var formatter = new EventTextFormatter(EventTextFormatter.DashSeparator);
try
{
using (var listener = new ObservableEventListener())
{
listener.LogToFlatFile(fileName, formatter);
}
}
catch (UnauthorizedAccessException ex)
{
Assert.AreEqual("Access to the path '" + path + "\\" + fileName + "' is denied.", ex.Message);
}
}
public void WhenReadOnlyFolder()
{
var fileName = "newflatfileInReadOnlyFolder.log";
var folderName = "ReadOnlyFolder";
string path = Directory.GetCurrentDirectory();
string completePath = Path.Combine(path, folderName);
DirectoryInfo dir = new DirectoryInfo(completePath);
var formatter = new EventTextFormatter(EventTextFormatter.DashSeparator);
if (Directory.Exists(completePath))
{
dir.Attributes &= ~FileAttributes.ReadOnly;
Directory.Delete(completePath, true);
}
try
{
Directory.CreateDirectory(completePath);
dir.Attributes |= FileAttributes.ReadOnly;
var folderfilePath = Path.Combine(completePath, fileName);
using (var listener = new ObservableEventListener())
{
listener.LogToFlatFile(folderfilePath, formatter);
}
Assert.IsFalse(File.Exists(fileName));
}
finally
{
dir.Attributes &= ~FileAttributes.ReadOnly;
Directory.Delete(completePath, true);
}
}