private void WcfConnect(ProgressDialog prg) { // set up callback to track tasks loading progress: var progressCbk = new ProgressCallback(delegate(int from, int to, int current) { prg.SetProgress(20 + (current * 80) / (to - from), string.Format("Loading task {0} of {1}...", current + 1, to - from)); }); prg.SetProgress(10, "Connecting to service..."); WcfDisconnect(); try { using (RegistryKey key = Registry.LocalMachine.OpenSubKey(C1ReportsSchedulerService.Constants.RegKey_Root)) { string baseAddr = key.GetValue(C1ReportsSchedulerService.Constants.RegKey_WcfEndpointBaseAddress) as string; string relAddr = key.GetValue(C1ReportsSchedulerService.Constants.RegKey_WcfEndpointRelAddress) as string; // todo: check how base and rel addresses are combined: #if wcf_http WcfEndpointAddress = string.Format("{0}/{1}", baseAddr, relAddr); #else WcfEndpointAddress = string.Format("{0}/{1}", baseAddr, relAddr); #endif } LoadTasks(new TaskListHolderClient(this, WcfEndpointAddress, progressCbk)); } catch (Exception ex) { WinUtil.ShowError(string.Format("Could not get service endpoint address from registry: {0}", ex.Message)); } }
private void StartStopSchedule() { TaskBase task = CurrentTask; if (task == null) { return; } bool start = !task.Schedule.Enabled; if (start) { System.Diagnostics.Debug.Assert(task.State == TaskState.Ready); if (task.Check(true)) { task.Schedule.Enabled = true; } else { WinUtil.ShowError(string.Format("Could not start schedule - task has errors: {0}", task.Message)); } } else { task.Schedule.Enabled = false; } }
public static void ShowError(string message) { #if SERVICE C1ReportsSchedulerService.Logger.Log("ERROR", message); #else WinUtil.ShowError(message); #endif }
private void ConnectToService(ProgressDialog prg) { System.Diagnostics.Debug.Assert(CanConnectToService(false)); try { WcfConnect(prg); } catch (Exception ex) { WinUtil.ShowError(string.Format("Cannot connect to service {0}: {1}.", C1ReportsSchedulerService.Constants.Name, ex.Message)); } }
internal void FileOpen(string fileName) { try { LoadTasks(TaskListHolder.Load(fileName)); C1rsconfFileName = fileName; } catch (Exception ex) { WinUtil.ShowError(ex.Message); C1rsconfFileName = null; } }
static public void Load(MainForm mainForm) { UiSettings uiSettings = Properties.Settings.Default.UiSettings; if (uiSettings != null) { mainForm.UiSettings = uiSettings; } mainForm.WcfEndpointAddress = Properties.Settings.Default.EndpointAddress; if (Properties.Settings.Default.ClientMode) { if (!mainForm.ClientMode) { mainForm.ConnectToServiceOnLoad(); } } else { TaskListStore store = Properties.Settings.Default.TaskListStore; switch (store) { case TaskListStore.AppConfigFile: string tasksXml = Properties.Settings.Default.C1ReportsSchedulerTasks; if (!string.IsNullOrEmpty(tasksXml)) { try { using (MemoryStream ms = new MemoryStream(UTF8Encoding.Default.GetBytes(tasksXml))) mainForm.LoadTasks(TaskListHolder.Load(ms)); } catch (Exception ex) { WinUtil.ShowError(string.Format("Error loading tasks from config file: {0}", ex.Message)); } } break; case TaskListStore.XmlFile: mainForm.FileOpen(Properties.Settings.Default.C1rsconfFileName); break; default: System.Diagnostics.Debug.Assert(false); break; } } }
private bool UiTaskSelectFileName(TaskBase task) { try { using (OpenFileDialog ofd = new OpenFileDialog()) { ofd.Filter = "Report definition files (*.xml)|*.xml|C1DX documents(*.c1dx)|*.c1dx|C1D documents (*.c1d)|*.c1d|Executable files (*.exe)|*.exe|All files (*.*)|*.*"; if (ofd.ShowDialog() == DialogResult.OK) { task.FileName = ofd.FileName; switch (Path.GetExtension(ofd.FileName).ToLowerInvariant()) { case ".xml": if (task.ReportKind == ReportKind.C1dDocument) { task.ReportKind = ReportKind.XmlReport; } break; case ".c1d": case ".c1dx": if (task.ReportKind != ReportKind.C1dDocument) { task.ReportKind = ReportKind.C1dDocument; } break; case ".exe": if (task.ReportKind != ReportKind.Program) { task.ReportKind = ReportKind.Program; } break; } return(true); } else { return(false); } } } catch (Exception ex) { WinUtil.ShowError(ex.Message); return(false); } }
private void ServiceCall(ServiceControllerStatus desiredStatus, string actionName, ProgressDialog prg) { prg.SetProgress(10, string.Format("{0} {1} service...", actionName, C1ReportsSchedulerService.Constants.Name)); using (ServiceController sc = new ServiceController(C1ReportsSchedulerService.Constants.Name)) { try { if (sc.Status == desiredStatus) { return; } switch (desiredStatus) { case ServiceControllerStatus.Paused: sc.Pause(); break; case ServiceControllerStatus.Running: if (sc.Status == ServiceControllerStatus.Paused) { sc.Continue(); } else { sc.Start(); } break; case ServiceControllerStatus.Stopped: sc.Stop(); break; default: System.Diagnostics.Debug.Assert(false); break; } WaitForStatus(sc, desiredStatus, prg); } catch (Exception ex) { WinUtil.ShowError(string.Format("Error: {0}", ex.Message)); } finally { sc.Close(); } } }
private bool UiActionSelectFileName(ActionBase action) { try { switch (action.Kind) { case ActionKind.Export: SaveFileDialog sfd = new SaveFileDialog(); sfd.Filter = "All files (*.*)|*.*"; if (!string.IsNullOrEmpty(action.ExportFormatKey)) { sfd.Filter = string.Format("{0} (*.{1})|*.{1}|", action.ExportFormatName, action.ExportDefaultExtension) + sfd.Filter; } if (sfd.ShowDialog() == DialogResult.OK) { action.OutputFileName = sfd.FileName; return(true); } break; case ActionKind.Print: PrintDialog pdlg = new PrintDialog(); if (pdlg.ShowDialog() == DialogResult.OK) { // todo: save all print settings action.OutputFileName = pdlg.PrinterSettings.PrinterName; return(true); } break; case ActionKind.Run: break; default: System.Diagnostics.Debug.Assert(false); break; } return(false); } catch (Exception ex) { WinUtil.ShowError(ex.Message); return(false); } }
void _taskGrid_RowsAdded(object sender, DataGridViewRowsAddedEventArgs e) { try { for (int i = 0; i < e.RowCount; ++i) { TaskBase task = Tasks[e.RowIndex + i]; task.Actions.Invoker = this; UpdateTaskGridReportList(e.RowIndex + i); OnTaskStateChanged(task); task.PropertyChanged += new PropertyChangedEventHandler(TaskPropertyChanged); } } catch (Exception ex) { WinUtil.ShowError(ex.Message); } }
/// <summary> /// Set task grid row's properties according to task state. /// If the passed task is current, also updates actions and schedule panels. /// </summary> /// <param name="task"></param> private void OnTaskStateChanged(TaskBase task) { if (task == null) { return; } try { int taskIdx = Tasks.IndexOf(task); // ignore state change from task if it's not in grid - assume // that it was removed while executing: // System.Diagnostics.Debug.Assert(taskIdx >= 0); if (taskIdx < 0) { return; } bool ro = task.State != TaskState.Ready; _taskGrid.Rows[taskIdx].ReadOnly = ro; if (task == CurrentTask) { _actionGrid.ReadOnly = ro; foreach (ActionBase a in task.Actions) { UpdateActionGridCellsReadonlyState(a); } SetReadOnlyRecursive(grpSchedule.Controls, ro); // for "one time" schedules, repeat freq/unit must be adjusted: numScheduleRepeatFreq.Enabled = chkScheduleRepeat.Checked; cmbScheduleRepeatUnit.Enabled = chkScheduleRepeat.Checked; SetReadOnlyRecursive(flwScheduleFrequency.Controls, ro); dtpScheduleDate.Enabled = !ro; dtpScheduleTime.Enabled = !ro; } } catch (Exception ex) { WinUtil.ShowError(ex.Message); } }
private void FileOpen() { try { if (!ConfirmNewOrLoadTasks()) { return; } using (OpenFileDialog ofd = new OpenFileDialog()) { ofd.Filter = string.Format("{0} config files (*{1})|*{1}|All files (*.*)|*.*", C1ReportsSchedulerService.Constants.Name, C1ReportsSchedulerService.Defaults.C1rsconfFileExt); if (ofd.ShowDialog() == DialogResult.OK) { FileOpen(ofd.FileName); } } } catch (Exception ex) { WinUtil.ShowError(string.Format("Could not load from the selected file: {0}", ex.Message)); NewTasks(); } }
private bool CanConnectToService(bool showErrors, out bool serviceInstalled) { serviceInstalled = false; using (ServiceController sc = new ServiceController(C1ReportsSchedulerService.Constants.Name)) { try { if (sc.Status == ServiceControllerStatus.Running || sc.Status == ServiceControllerStatus.Paused) { serviceInstalled = true; return(true); } else { if (showErrors) { WinUtil.ShowError(string.Format("Cannot connect to service {0}: it is not running.", C1ReportsSchedulerService.Constants.Name)); } serviceInstalled = true; return(false); } } catch (Exception ex) { if (showErrors) { WinUtil.ShowError(string.Format("Could not access service {0}: {1}", C1ReportsSchedulerService.Constants.Name, ex.Message)); } return(false); } finally { sc.Close(); } } }
private void Command_Click(object sender, EventArgs e) { // avoid recursive command calls: if (!_timer.Enabled) { return; } // we turn service pinging off for the duration of the command. _timer.Stop(); try { Command cmd = _commandMap[sender]; cmd(); } catch (Exception ex) { WinUtil.ShowError(ex.Message); } finally { _timer.Start(); } }
private void ServiceStart(ProgressDialog progress, bool unconditionalTransfer) { using (ServiceController sc = new ServiceController(C1ReportsSchedulerService.Constants.Name)) { try { progress.SetProgress(5, "Checking service status..."); sc.WaitForStatus(ServiceControllerStatus.Stopped, c_timeout); ServiceControllerStatus status = sc.Status; if (status != ServiceControllerStatus.Stopped) { WinUtil.ShowError("Service is running or paused!"); return; } string currentTaskListFile = null; bool transfer = unconditionalTransfer; if (!transfer && _tasksHolder.Tasks.Count > 0) { transfer = WinUtil.AskQuestion("Transfer current task list to service?", false); } if (transfer) { progress.SetProgress(10, "Stopping running schedules..."); _tasksHolder.StopSchedules(); progress.SetProgress(20, "Preparing current task list for transfer..."); currentTaskListFile = Path.GetTempFileName(); _tasksHolder.Save(currentTaskListFile); } this.Clear(); progress.SetProgress(30, string.Format("Starting {0} service...", C1ReportsSchedulerService.Constants.Name)); if (string.IsNullOrEmpty(currentTaskListFile)) { sc.Start(); } else { sc.Start(new string[] { currentTaskListFile }); } WaitForStatus(sc, ServiceControllerStatus.Running, progress); sc.ExecuteCommand((int)C1ReportsSchedulerService.CustomCommands.ResetC1rsconfFileToRegistry); progress.SetProgress(90, "Connecting to service..."); ConnectToService(progress); progress.SetProgress(90, "Service successfully started."); if (!string.IsNullOrEmpty(currentTaskListFile)) { File.Delete(currentTaskListFile); } } catch (Exception ex) { WinUtil.ShowError(string.Format("Error: {0}", ex.Message)); } finally { sc.Close(); } } }
private void ServiceSetup() { // find out whether the service is installed or not: bool serviceInstalled = false; ServiceControllerStatus serviceStatus = ServiceControllerStatus.ContinuePending; // some assigned value using (ServiceController sc = new ServiceController(C1ReportsSchedulerService.Constants.Name)) { try { serviceStatus = sc.Status; serviceInstalled = true; } catch { } finally { sc.Close(); } } // try getting values from registry, use defaults if unsuccessful: string sWcfEndpointBaseAddress = C1ReportsSchedulerService.Defaults.WcfEndpointBaseAddress; string sWcfEndpointRelAddress = C1ReportsSchedulerService.Defaults.WcfEndpointRelAddress; string sC1rsconfFilePath = string.Format(@"{0}\{1}{2}", Application.CommonAppDataPath, C1ReportsSchedulerService.Defaults.C1rsconfFileName, C1ReportsSchedulerService.Defaults.C1rsconfFileExt); bool sAutoStart = serviceInstalled ? ServiceInstaller.InstallService.GetAutoStartValue(C1ReportsSchedulerService.Constants.Name) : false; bool sLogTasks = C1ReportsSchedulerService.Defaults.LogTasks; bool sLogActions = C1ReportsSchedulerService.Defaults.LogActions; bool sLogProgramOutput = C1ReportsSchedulerService.Defaults.LogProgramOutput; bool sEnableMex = C1ReportsSchedulerService.Defaults.EnableMex; try { using (RegistryKey key = Registry.LocalMachine.OpenSubKey(C1ReportsSchedulerService.Constants.RegKey_Root)) { sWcfEndpointBaseAddress = key.GetValue(C1ReportsSchedulerService.Constants.RegKey_WcfEndpointBaseAddress) as string; sWcfEndpointRelAddress = key.GetValue(C1ReportsSchedulerService.Constants.RegKey_WcfEndpointRelAddress) as string; sC1rsconfFilePath = key.GetValue(C1ReportsSchedulerService.Constants.RegKey_C1rsconfFilePath) as string; sLogTasks = (int)key.GetValue(C1ReportsSchedulerService.Constants.RegKey_LogTasks) != 0; sLogActions = (int)key.GetValue(C1ReportsSchedulerService.Constants.RegKey_LogActions) != 0; sLogProgramOutput = (int)key.GetValue(C1ReportsSchedulerService.Constants.RegKey_LogProgramOutput) != 0; sEnableMex = (int)key.GetValue(C1ReportsSchedulerService.Constants.RegKey_EnableMex) != 0; } } catch { // eat errors here } // show dialog to set up service parameters (WCF comm address etc): using (ServiceInstallDialog sid = new ServiceInstallDialog()) { sid.WcfEndpointBaseAddress = sWcfEndpointBaseAddress; sid.WcfEndpointRelAddress = sWcfEndpointRelAddress; sid.C1rsconfFilePath = sC1rsconfFilePath; sid.AutoStart = sAutoStart; sid.LogTasks = sLogTasks; sid.LogActions = sLogActions; sid.LogProgramOutput = sLogProgramOutput; sid.EnableMex = sEnableMex; if (sid.ShowDialog(this) != DialogResult.OK) { return; } // copy back values from the dialog: sWcfEndpointBaseAddress = sid.WcfEndpointBaseAddress; sWcfEndpointRelAddress = sid.WcfEndpointRelAddress; sC1rsconfFilePath = sid.C1rsconfFilePath; sAutoStart = sid.AutoStart; sLogTasks = sid.LogTasks; sLogActions = sid.LogActions; sLogProgramOutput = sid.LogProgramOutput; sEnableMex = sid.EnableMex; } // install service if it is not installed, stop (so that the new settings will be applied) otherwise: using (ProgressDialog prg = new ProgressDialog()) { if (!serviceInstalled) { // install service: prg.SetProgress(10, "Installing service..."); // find service executable (must be in same directory as current app): string serviceExe = WinUtil.FindServiceExe(); if (string.IsNullOrEmpty(serviceExe)) { WinUtil.ShowError(string.Format("Could not find the service executable {0}", WinUtil.ServiceExeName)); return; } // install service: ServiceInstaller.InstallService.Install(serviceExe, C1ReportsSchedulerService.Constants.Name, C1ReportsSchedulerService.Constants.Name, sAutoStart); ServiceInstaller.InstallService.SetDescription(C1ReportsSchedulerService.Constants.Name, C1ReportsSchedulerService.Constants.Description); } else { DisconnectFromService(); // stop service (restart will pick up new settings): ServiceCall(ServiceControllerStatus.Stopped, "Stopping", prg); // update "autostart" parameter: ServiceInstaller.InstallService.SetAutoStartValue(C1ReportsSchedulerService.Constants.Name, sAutoStart); } // set up service via additional registry keys: using (RegistryKey key = Registry.LocalMachine.OpenSubKey(C1ReportsSchedulerService.Constants.RegKey_Root, true)) { key.SetValue(C1ReportsSchedulerService.Constants.RegKey_WcfEndpointBaseAddress, sWcfEndpointBaseAddress, RegistryValueKind.String); key.SetValue(C1ReportsSchedulerService.Constants.RegKey_WcfEndpointRelAddress, sWcfEndpointRelAddress, RegistryValueKind.String); key.SetValue(C1ReportsSchedulerService.Constants.RegKey_C1rsconfFilePath, sC1rsconfFilePath, RegistryValueKind.String); key.SetValue(C1ReportsSchedulerService.Constants.RegKey_LogTasks, sLogTasks ? 1 : 0, RegistryValueKind.DWord); key.SetValue(C1ReportsSchedulerService.Constants.RegKey_LogActions, sLogActions ? 1 : 0, RegistryValueKind.DWord); key.SetValue(C1ReportsSchedulerService.Constants.RegKey_LogProgramOutput, sLogProgramOutput ? 1 : 0, RegistryValueKind.DWord); key.SetValue(C1ReportsSchedulerService.Constants.RegKey_EnableMex, sEnableMex ? 1 : 0, RegistryValueKind.DWord); } // create event log: if (!EventLog.SourceExists(C1ReportsSchedulerService.Constants.EventLogSourceName)) { // optional but why not... prg.SetProgress(prg.Complete + 5, "Creating service event log source..."); EventLog.CreateEventSource(C1ReportsSchedulerService.Constants.EventLogSourceName, C1ReportsSchedulerService.Constants.EventLogName); } // start service: ServiceStart(prg, false); } }
private void TestClientModeOnStart() { if (Properties.Settings.Default.ClientMode) { return; } bool serviceInstalled; if (CanConnectToService(false, out serviceInstalled)) { // connect to a running service: string text = "You're about to start C1ReportsScheduler app in standalone mode.\r\n" + "But, it appears that C1Reports scheduling service is installed and running.\r\n" + "For full functionality it is highly recommended that you connect to the C1Reports scheduling service, " + "and use the C1ReportsScheduler (this application) in client mode to communicate with the service.\r\n\r\n" + "Do you want to connect to the service now?\r\n" ; if (WinUtil.AskQuestion(text, false)) { Properties.Settings.Default.ClientMode = true; } } else if (serviceInstalled) { // warn about a stopped service: string text = "You're about to start C1ReportsScheduler app in standalone mode.\r\n" + "But, it appears that C1Reports scheduling service is installed but is not running.\r\n" + "For full functionality it is highly recommended that you start the C1Reports scheduling service, " + "and use the C1ReportsScheduler (this application) in client mode to communicate with the service.\r\n\r\n" + "Use menu Service | Start to start the service and connect to it.\r\n" ; WinUtil.ShowWarning(text); } else { // offer to install and start service: string text = "You're about to start C1ReportsScheduler app in standalone mode.\r\n" + "Standalone mode provides limited scheduling functionality, as scheduled reports will not run when the application is closed.\r\n" + "For full functionality it is highly recommended that you install the C1Reports scheduling service, " + "and use the C1ReportsScheduler (this application) in client mode to communicate with the service.\r\n\r\n" + "Do you want to install the service now?\r\n\r\n" + "(You can install or uninstall the service at any time via the \"Service\" menu.)" ; if (WinUtil.AskQuestion(text, false)) { try { ServiceSetup(); Properties.Settings.Default.ClientMode = true; } catch (Exception ex) { WinUtil.ShowError(ex.Message); } } } }