public async Task RenderTemplateAsync_WhenTemplateExistsAndModelProvided_ShouldRenderTemplate()
        {
            // Arrange
            var expectedStrings = new List <string>();

            var enterpeiseSystem = "Build Orbit";
            var application      = "Marketing Application";
            var title            = "Load Balanced Virtual Machines";
            var jobStart         = new JobStart(title, enterpeiseSystem, application,
                                                new List <VirtualMachine>
            {
                new VirtualMachine("A12345678", 90d, 27d),
                new VirtualMachine("B24681012", 63d, 15.8d),
                new VirtualMachine("C135791113", 47d, 63d)
            });

            expectedStrings.Add(enterpeiseSystem);
            expectedStrings.Add(application);
            expectedStrings.Add(title);

            foreach (var vm in jobStart.VirtualMachines)
            {
                expectedStrings.Add(vm.Name);
                expectedStrings.Add(vm.Cpu.ToString());
                expectedStrings.Add(vm.Memory.ToString());
            }

            // Act
            var fullHtmlContent = await _razorTemplateEngine.RenderTemplateAsync(jobStart);

            // Assert
            AssertStringContains(fullHtmlContent, expectedStrings);
        }
Esempio n. 2
0
        public static async Task Main(string[] args)
        {
            var enterpeiseSystem = "Build Orbit";
            var application      = "Marketing Application";
            var title            = "Load Balanced Virtual Machines";
            var jobStart         = new JobStart(title, enterpeiseSystem, application,
                                                new List <VirtualMachine>
            {
                new VirtualMachine("A12345678", 90d, 27d),
                new VirtualMachine("B24681012", 84d, 15.8d),
                new VirtualMachine("C135791113", 47d, 63d)
            });

            var razorTemplateEngine = new RazorTemplateEngineV2();
            var htmlContent         = await razorTemplateEngine.RenderTemplateAsync(jobStart);

            var tempFile = Path.Combine(Path.GetTempPath(), "temp.html");
            await File.WriteAllTextAsync(tempFile, htmlContent);

            Process.Start(@"cmd.exe ", $@"/c {tempFile}");

            ////SendEmail(htmlContent);
        }
Esempio n. 3
0
        internal static void RunJob(Schedule schedule)
        {
            if (schedule.Disabled)
            {
                return;
            }

            lock (_running)
            {
                if (schedule.Reentrant != null &&
                    _running.Any(t => ReferenceEquals(t.Item1.Reentrant, schedule.Reentrant)))
                {
                    //non-reentrant and exists current schedule running job.
                    return;
                }
            }
            Tuple <Schedule, Task> tuple = null;
            var task = new Task(() =>
            {
                var start = Now;
                JobStart?.Invoke(new JobStartedEvent
                {
                    Name      = schedule.Name,
                    StartTime = start
                });
                var stopWatch = new Stopwatch();
                try
                {
                    stopWatch.Start();
                    schedule.Jobs.ForEach(action =>
                    {
                        //Record Time Duration.
                        Task.Factory.StartNew(action).Wait();
                    });
                }
                catch (Exception ex)
                {
                    if (JobException != null)
                    {
                        if (ex is AggregateException aggregate && aggregate.InnerExceptions.Count == 1)
                        {
                            ex = aggregate.InnerExceptions.Single();
                        }
                        JobException(new JobExceptionRaisedEvent
                        {
                            Name      = schedule.Name,
                            Message   = ex.Message,
                            Exception = ex,
                            RaiseTime = DateTime.Now
                        });
                    }
                }
                finally
                {
                    lock (_running)
                    {
                        _running.Remove(tuple);
                    }
                    JobEnd?.Invoke(new JobEndedEvent
                    {
                        Duration  = TimeSpan.FromMilliseconds(stopWatch.ElapsedMilliseconds),
                        Name      = schedule.Name,
                        NextRun   = schedule.NextRun,
                        StartTime = start,
                    });
                }
            }, TaskCreationOptions.PreferFairness);

            tuple = new Tuple <Schedule, Task>(schedule, task);
            lock (_running)
            {
                _running.Add(tuple);
            }
            task.Start();
        }