示例#1
0
        } // constructor

        public static bool IsRecordSchedulerTask(Task schedulerTask, out RecordTask recordTask)
        {
            recordTask = null;

            if (string.IsNullOrEmpty(schedulerTask.Definition.RegistrationInfo.Documentation))
            {
                return(false);
            }
            if (string.IsNullOrEmpty(schedulerTask.Definition.Data))
            {
                return(false);
            }

            if (!schedulerTask.Definition.RegistrationInfo.Documentation.StartsWith(Resources.DefinitionRegistrationInfo_Documentation_Begins, StringComparison.InvariantCultureIgnoreCase))
            {
                return(false);
            } // if

            try
            {
                recordTask = RecordTaskSerialization.LoadFromXmlString(schedulerTask.Definition.Data);
                return(true);
            }
            catch
            {
                // ignore, but return a null RecordTask
                return(false);
            } // try-catch
        }     // IsRecordSchedulerTask
示例#2
0
        } // CanRecord

        public static RecordTask GetRecordTask(UiBroadcastService service, EpgProgram epgProgram, DateTime localReferenceTime)
        {
            var channel = GetRecordChannel(service);

            if (epgProgram == null)
            {
                return(RecordTask.CreateWithDefaultValues(channel));
            } // if

            var isCurrent   = epgProgram.IsCurrent(localReferenceTime);
            var program     = GetRecordProgram(epgProgram);
            var schedule    = GetRecordSchedule(epgProgram, isCurrent);
            var duration    = GetRecordDuration(epgProgram, isCurrent);
            var description = GetRecordDescription(epgProgram, channel);
            var action      = GetRecordAction(service, epgProgram);
            var advanced    = GetRecordAdvancedSettings();

            var task = new RecordTask()
            {
                Channel          = channel,
                Program          = program,
                Schedule         = schedule,
                Duration         = duration,
                Description      = description,
                Action           = action,
                AdvancedSettings = advanced,
            };

            return(task);
        } // GetRecordTask
示例#3
0
        } // LaunchRecorderProgram

        private IDictionary <string, string> CreateParameters(string filename, RecordTask task)
        {
            var paramKeys = new string[]
            {
                "OutputFile",
                "Channel.Url",
                "Channel.Name",
                "Channel.Description",
                "Description.Name",
                "Description.Description",
                "Duration.TotalSeconds",
            };
            var paramValues = new string[]
            {
                filename,
                task.Channel.ChannelUrl,
                task.Channel.Name,
                task.Channel.Description,
                task.Description.Name,
                task.Description.Description,
                ((int)TotalTime.TotalSeconds).ToString(CultureInfo.InvariantCulture),
            };

            return(ArgumentsManager.CreateParameters(paramKeys, paramValues, false));
        } // CreateParameters
示例#4
0
        }     // SetSchedule

        private void SetDescription(TaskDefinition definition, RecordTask task)
        {
            string userDescription;

            _taskName = GetUniqueTaskName(task, "IPTViewr");
            task.Description.TaskSchedulerName = _taskName;

            userDescription = task.Description.Description;
            if (!task.Description.AddDetails)
            {
                if (userDescription.Length > 0)
                {
                    definition.RegistrationInfo.Description = userDescription;
                } // if
            }
            else
            {
                var details = new StringBuilder();
                task.BuildDescription(true, false, false, true, true, true, null, details);
                task.Description.Details = details.ToString();

                if (userDescription.Length > 0)
                {
                    details = new StringBuilder(userDescription.Length + task.Description.Details.Length + 2);
                    details.Append(userDescription);
                    details.AppendLine();
                    details.Append(task.Description.Details);
                } // if
                details.Replace("\r\n", "  \r\n");

                definition.RegistrationInfo.Description = details.ToString();
            } // if-else
        }     // SetDescription
示例#5
0
        } // DialogRecordChannel_Shown

        #endregion

        #region Form events implementation

        private void DialogRecordChannel_Load_Implementation(object sender, EventArgs e)
        {
            BasicGoogleTelemetry.SendScreenHit(this);

            // Initialize
            if (Task == null)
            {
                if (this.DesignMode)
                {
                    Task      = RecordTask.CreateWithDefaultValues(null);
                    IsNewTask = true;
                }
                else
                {
                    throw new ArgumentNullException();
                } // if-else
            }     // if

            // General
            InitGeneralData();
            // Schedule tab
            InitScheduleData();
            // Duration tab
            InitDurationData();
            // Description tab
            InitDescriptionData();
            // Save tab
            InitSaveData();
            // Advanced tab
            InitAdvancedData();
        } // DialogRecordChannel_Load_Implementation
示例#6
0
        } // SaveXmlData

        private static void SetAdditionalData(TaskDefinition definition, RecordTask record, string dbFile)
        {
            definition.RegistrationInfo.Author        = $"{Assembly.GetEntryAssembly().GetName().Name} {SolutionVersion.ProductVersion}";
            definition.RegistrationInfo.Source        = Resources.DefinitionRegistrationInfo_Source;
            definition.RegistrationInfo.Documentation = string.Format(Resources.DefinitionRegistrationInfo_Documentation, record.TaskId, dbFile);
            definition.RegistrationInfo.Date          = DateTime.Now;
            definition.Data = record.SaveAsString();
        } // SetAdditionalData
示例#7
0
        } // CreateWindowsJob

        private void DisplayTaskData(RecordTask task, TimeSpan totalRecordTime)
        {
            var buffer = new StringBuilder();

            task.BuildDescription(false, true, false, true, true, true, totalRecordTime, buffer);
            buffer.AppendLine();

            Console.WriteLine(buffer.ToString());
        } // DisplayTaskData
示例#8
0
        } // GetRecordAdvancedSettings

        public static bool ScheduleTask(CommonBaseForm ownerForm, RecordTask task)
        {
            // schedule task
            var scheduler = new Scheduler(ownerForm.GetExceptionHandler(),
                                          AppUiConfiguration.Current.Folders.RecordTasks, AppUiConfiguration.Current.User.Record.RecorderLauncherPath);

            if (scheduler.CreateTask(task))
            {
                MessageBox.Show(ownerForm, Properties.Resources.SchedulerCreateTaskOk, ownerForm.Text, MessageBoxButtons.OK, MessageBoxIcon.Information);
                return(true);
            } // if

            return(false);
        } // ScheduleTask
示例#9
0
        }             // ProcessTasks

        private void AddSchedulerTask(Task schedulerTask, RecordTask recordTask)
        {
            TaskData taskData;

            taskData = new TaskData()
            {
                Status        = TaskStatus.MissingXml,
                SchedulerName = schedulerTask.Name,
                SchedulerPath = schedulerTask.Folder.Path,
                Task          = recordTask
            };

            List.Add(taskData);
        } // AddSchedulerTask
示例#10
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="db"></param>
 public RecordManager(SqlSugarScope db, ILogger <RecordManager> logger)
 {
     this.db  = db;
     records  = new RecordTask(logger);
     tasks    = new RecordTask(logger);
     last     = DateTime.Now;
     duration = TimeSpan.FromSeconds(2);
     worker   = new Thread(() =>
     {
         var watch = new Stopwatch();
         var count = 0;
         watch.Start();
         while (true)
         {
             try
             {
                 watch.Restart();
                 lock (records)
                 {
                     if (records.Count > 0)
                     {
                         last = DateTime.Now;
                         records.Switch(tasks);
                     }
                 }
                 count = tasks.Count;
                 if (tasks.Count > 0)
                 {
                     tasks.WriteDown(db);
                     logger.LogInformation("write down final");
                 }
                 watch.Stop();
                 if (count > 0)
                 {
                     logger.LogInformation("down: {0}ms {1}", watch.ElapsedMilliseconds, count);
                 }
             }
             catch (Exception e)
             {
                 logger.LogError("write down: {0}", e);
             }
             Thread.Sleep(duration);
         }
     });
     worker.Start();
     logger.LogInformation("Start Worker.");
     this.logger = logger;
 }
示例#11
0
        } // SetSchedule

        private static string GetUniqueTaskName(RecordTask task, string prefix)
        {
            string format;
            string description;

            description = task.Description.Name;
            if (task.Description.AddPrefix)
            {
                format = (description.Length > 0) ? "{2} ~ {0} {1:P}" : "{2} {1:P}";
            }
            else
            {
                format = (description.Length > 0) ? "{0} {1:P}" : "{2} {1:P}";
            } // if-else

            return(string.Format(format, description, task.TaskId, prefix));
        } // GetUniqueTaskName
示例#12
0
        } // GetTaskSchedulerFolder

        private void GetDuration(RecordTask task)
        {
            // set duration if EndDateTime
            if (task.Duration.EndDateTime != null)
            {
                task.Duration.Length = task.Duration.GetDuration(task.Schedule);
            } // if-else

            // extract start details
            _startSafetyMargin = task.Schedule.SafetyMarginTimeSpan;

            // extract duration details
            _endSafetyMargin = task.Duration.SafetyMarginTimeSpan;
            _recordDuration  = task.Duration.Length;

            // do some math
            _totalRecordTime = _startSafetyMargin + _recordDuration + _endSafetyMargin;
        } // GetDuration
示例#13
0
        } // SetAdditionalData

        private void SetAction(TaskDefinition definition, RecordTask record, string dbFile, string logFolder)
        {
            var arguments = new[]
            {
                "/Action:Record",
                $"/TaskId:{record.TaskId}",
                $"/Database:{dbFile}",
                $"/LogFolder:{logFolder}"
            };

            var action = new ExecAction()
            {
                Path             = _recorderLauncherPath,
                Arguments        = ArgumentsManager.JoinArguments(arguments),
                WorkingDirectory = record.Action.SaveLocationPath,
            };

            definition.Actions.Add(action);
        } // SetAction
示例#14
0
        public static void TryUpload(RecordTask task, string path)
        {
            if (DoUpload)
            {
                ProcessStartInfo ps = new ProcessStartInfo
                {
                    FileName  = "BaiduPCS-Go",
                    Arguments = $"u {path} /{task.TaskName}_archives/",
                    RedirectStandardOutput = true,
                    StandardOutputEncoding = Encoding.UTF8
                };
                Process p = new Process();

                p.StartInfo = ps;
                p.Start();
                p.WaitForExit();
                Console.WriteLine(p.StandardOutput.ReadToEnd());
            }
        }
示例#15
0
        }     // IsRecordSchedulerTask

        public bool CreateTask(RecordTask record)
        {
            TaskService    taskScheduler;
            TaskDefinition definition;
            Task           task;
            bool           isOk;

            _taskFolder = null;
            _taskName   = null;

            taskScheduler = null;
            definition    = null;
            task          = null;
            isOk          = false;

            try
            {
                taskScheduler = new TaskService();
                definition    = taskScheduler.NewTask();

                // Get folder for new task
                _taskFolder = GetTaskSchedulerFolder(record.AdvancedSettings, taskScheduler);

                // "Duration"
                // Duration 'per-se' is handled by the recording process.
                // However, we need extract some information
                GetDuration(record);

                // "Schedule"
                SetSchedule(definition, record.Schedule);

                // "Description"
                SetDescription(definition, record);

                // "Save"
                // Save location is handled by the recording process

                // "Advanced"
                SetAdvancedSettings(definition.Settings, record.AdvancedSettings, record.Schedule.Kind == RecordScheduleKind.RightNow);

                // Save xml data
                SaveXmlData(record);

                // Aditional task data
                SetAdditionalData(definition, record, _dbFile);

                // Action
                SetAction(definition, record, _dbFile, _logFolder);

                // Register task
                task = _taskFolder.RegisterTaskDefinition(_taskName, definition);
                isOk = true;

                // Run task right now?
                if (record.Schedule.Kind != RecordScheduleKind.RightNow)
                {
                    return(true);
                }

                try
                {
                    task.Run();
                    return(true);
                }
                catch (Exception ex)
                {
                    _exceptionHandler(new ExceptionEventData(Texts.TaskRunException, ex));
                    return(false);
                } // try-catch
            }
            catch (Exception ex)
            {
                _exceptionHandler(new ExceptionEventData(Texts.TaskCreationException, ex));
                return(false);
            }
            finally
            {
                if (!isOk)
                {
                    RecordTaskSerialization.TryDeleteFromDatabase(record.TaskId, _dbFile);
                } // if
                if (task != null)
                {
                    task.Dispose();
                    task = null;
                } // if
                if (definition != null)
                {
                    definition.Dispose();
                    definition = null;
                } // if
                if (_taskFolder != null)
                {
                    _taskFolder.Dispose();
                    _taskFolder = null;
                } // if
                if (taskScheduler != null)
                {
                    taskScheduler.Dispose();
                    taskScheduler = null;
                } // if
                _taskName = null;
            }     // try-finally
        }         // CreateTask
示例#16
0
        }     // SetAdvancedSettings

        private void SaveXmlData(RecordTask record)
        {
            record.SaveToDatabase(_dbFile);
        } // SaveXmlData
示例#17
0
        } // DisplayTaskData

        private Program.Result LaunchRecorderProgram(RecordTask task)
        {
            var scheduledStartTime = task.Schedule.GetStartDateTime();
            var scheduledTotalTime = task.Schedule.SafetyMarginTimeSpan + task.Duration.GetDuration(task.Schedule) + task.Duration.SafetyMarginTimeSpan;
            var now = DateTime.Now;
            // var scheduledDateTime = new DateTime(scheduledStartTime.Year, scheduledStartTime.Month, scheduledStartTime.Day, scheduledStartTime.Hour, scheduledStartTime.Minute, scheduledStartTime.Second);
            // TODO: determine most probable launch date; we need to account for HUGE delays between scheduled run time and real run time
            var scheduledDateTime = new DateTime(now.Year, now.Month, now.Day, scheduledStartTime.Hour, scheduledStartTime.Minute, scheduledStartTime.Second);
            var gap = now - scheduledDateTime;

            if (gap.TotalSeconds < 1)
            {
                gap = TimeSpan.Zero;
            }
            TotalTime = scheduledTotalTime - gap;

            Logger.Log(Logger.Level.Verbose, Properties.Texts.LogVerboseScheduledStartTimeGap,
                       scheduledStartTime, scheduledTotalTime, gap, TotalTime);
            DisplayTaskData(task, TotalTime);

            if (TotalTime.TotalSeconds < 1)
            {
                Logger.Log(Logger.Level.Error, Properties.Texts.LogErrorTooLate);
                return(Program.Result.TooLate);
            } // if

            if (gap.TotalSeconds < 30)
            {
                gap = TimeSpan.Zero;
            }

            if (task.Schedule.Kind != RecordScheduleKind.RightNow)
            {
                if (gap.TotalSeconds > task.Schedule.SafetyMarginTimeSpan.TotalSeconds)
                {
                    RecordingLate = true;
                    Logger.Log(Logger.Level.Warning, Properties.Texts.LogWarningRecordingLate, (int)task.Schedule.SafetyMarginTimeSpan.TotalMinutes);
                    Console.WriteLine(Properties.Texts.DisplayWarningRecordingLate, (int)task.Schedule.SafetyMarginTimeSpan.TotalMinutes);
                }
                else if (gap.TotalSeconds > 0)
                {
                    Logger.Log(Logger.Level.Warning, Properties.Texts.LogWarningBehindSchedule, gap);
                    Console.WriteLine(Properties.Texts.DisplayWarningBehindSchedule, gap);
                } // if-else
            }     // if-else

            var date = string.Format(Properties.Texts.FormatRecordFileDate,
                                     now.Year, now.Month, now.Day,
                                     scheduledStartTime.Hour, scheduledStartTime.Minute, scheduledStartTime.Second);

            var filename = string.Format(Properties.Texts.FormatRecordFileName,
                                         task.Action.SaveLocationPath,
                                         task.Action.Filename,
                                         date,
                                         RecordingLate ? Properties.Texts.FormatRecordFileDelayed : null,
                                         task.Action.FileExtension);

            var parameters = CreateParameters(filename, task);

            LogParameters(parameters);
            var arguments       = ArgumentsManager.ExpandArguments(task.Action.Recorder.Arguments, parameters, Properties.Resources.ArgumentsOpenBrace, Properties.Resources.ArgumentsCloseBrace, StringComparison.CurrentCultureIgnoreCase);
            var joinedArguments = ArgumentsManager.JoinArguments(arguments);

            LogArguments(task.Action.Recorder.Path, task.Action.Recorder.Arguments, joinedArguments);

            try
            {
                var info = new ProcessStartInfo()
                {
                    FileName        = task.Action.Recorder.Path,
                    Arguments       = joinedArguments,
                    ErrorDialog     = false,
                    UseShellExecute = false,
                };

                Logger.Log(Logger.Level.Info, Properties.Texts.LogInfoLaunchingRecorder);
                Console.Write(Properties.Texts.DisplayLaunchingRecorder);
                using (var process = Process.Start(info))
                {
                    Logger.Log(Logger.Level.Info, Properties.Texts.LogInfoLaunchingRecorderOk, process.Id);
                    Console.WriteLine(Properties.Texts.DisplayLaunchingRecorderOk, process.Id);

                    TimerTickCount = 0;
                    StartTime      = DateTime.UtcNow;
                    var timer = new System.Threading.Timer(OnTimerTick, null, 0, 60000);

                    Logger.Log(Logger.Level.Verbose, Properties.Texts.LogVerboseWaitForExit);
                    process.WaitForExit();

                    timer.Dispose();
                    Logger.Log(Logger.Level.Info, Properties.Texts.LogInfoRecorderExited, process.ExitCode);

                    Console.WriteLine();
                    Console.WriteLine();
                    Console.WriteLine(Properties.Texts.DisplayRecorderFinished);

                    if (process.ExitCode != 0)
                    {
                        return(Program.Result.ExecFailure);
                    } // if
                }     // using
            }
            catch (Exception ex)
            {
                Logger.Exception(ex, Properties.Texts.LogExceptionLaunchingRecorder);
                Program.DisplayException(ex);

                return(Program.Result.ExecProblem);
            } // try-catch

            return(Program.Result.Ok);
        } // LaunchRecorderProgram