protected override void Process([NotNull] ProcessorArgs args) { Install9Args arguments = (Install9Args)args; Task task = arguments.Tasker.Tasks.FirstOrDefault(t => t.Name == this.taskName); PowerShellTask powershellTask = task as PowerShellTask; if (powershellTask != null) { string result = powershellTask.GetScript(); if (task.State == TaskState.Failed) { throw new AggregateException(string.Format("Failed to execute {0} task. \n{1}", task.Name, result)); } string path = Path.Combine(arguments.Tasker.GlobalParams.First(p => p.Name == "FilesRoot").Value, string.Format("generated_scripts/{0}", task.UnInstall ? "Uninstall" : "Install")); Directory.CreateDirectory(path); using (StreamWriter writer = new StreamWriter(Path.Combine(path, string.Format("{0}.ps1", task.Name)))) { writer.Write(powershellTask.GetScript()); } } else { this.Skip(); } }
public Wizard(WizardPipeline wizardPipeline, ProcessorArgs args, [NotNull] Func <WizardArgs> createWizardArgs) { using (new ProfileSection("Create wizard instance", this)) { ProfileSection.Argument("wizardPipeline", wizardPipeline); ProfileSection.Argument("args", args); WizardArgs = createWizardArgs(); if (WizardArgs != null) { WizardArgs.WizardWindow = this; } WizardPipeline = wizardPipeline; Args = args; InitializeComponent(); ProgressBar1Foreground = progressBar1.Foreground; if (!WinAppSettings.AppSysIsSingleThreaded.Value) { CancelButton.IsCancel = false; ResizeMode = ResizeMode.CanMinimize; } } Initialize(); }
public override void Process(ProcessorArgs args) { var notifyIconManager = Factory.ActualFactory.GetNotifyIconManager(); args.CurrentNotifyIconChangerClient.SetIcon( args.ResolvedHandler != null ? args.ResolvedHandler.DefaultHandlerIcon : this.SuccessTrayIcon, 1500); }
public virtual void Process(ProcessorArgs args) { if (Context.Site?.Properties["enableDianoga"] == "false") { args.AbortPipeline(); } }
protected override void Process(ProcessorArgs args) { string scriptFile = Path.Combine(Directory.GetCurrentDirectory(), "ContainerFiles/scripts/InstallDockerToolsModuleScript.txt"); PSFileExecutor ps = new PSFileExecutor(scriptFile, Directory.GetCurrentDirectory()); ps.Execute(); }
protected override void Process([NotNull] ProcessorArgs args) { Install9Args arguments = (Install9Args)args; if (!arguments.Tasker.UnInstall || arguments.ScriptsOnly) { this.Skip(); return; } InstallParam sqlDbPrefixParam = arguments.Tasker.GlobalParams.FirstOrDefault(p => p.Name == "SqlDbPrefix"); if (sqlDbPrefixParam != null && !string.IsNullOrEmpty(sqlDbPrefixParam.Value)) { foreach (SitecoreEnvironment sitecoreEnvironment in SitecoreEnvironmentHelper.SitecoreEnvironments) { if (sitecoreEnvironment.Name == sqlDbPrefixParam.Value) { SitecoreEnvironmentHelper.SitecoreEnvironments.Remove(sitecoreEnvironment); SitecoreEnvironmentHelper.SaveSitecoreEnvironmentData(SitecoreEnvironmentHelper.SitecoreEnvironments); return; } } } }
public override long EvaluateStepsCount(ProcessorArgs args) { var download = (Download8Args)args; var count = download._FileNames.Count(x => RequireDownloading(x.Value, download.LocalRepository)); return(count * Scale); }
protected override void ProcessOptimize(ProcessorArgs args) { if (_supportedExtensionsLookup.Contains(args.InputStream.Extension)) { if (args.ResultStream == null) { // MakeStreamSeekable will buffer the stream if its not seekable args.InputStream.MakeStreamSeekable(); args.InputStream.Stream.Seek(0, SeekOrigin.Begin); } var sourceStream = args.ResultStream ?? args.InputStream.Stream; var optimizerArgs = new OptimizerArgs(sourceStream, args.MediaOptions); CorePipeline.Run(Pipeline, optimizerArgs); args.IsOptimized = optimizerArgs.IsOptimized; args.Extension = optimizerArgs.Extension; args.ResultStream = optimizerArgs.Stream; if (!string.IsNullOrEmpty(optimizerArgs.Message)) { args.AddMessage(optimizerArgs.Message); } if (optimizerArgs.Aborted) { args.AbortPipeline(); } } }
protected override void Process([NotNull] ProcessorArgs arguments) { Assert.ArgumentNotNull(arguments, "arguments"); InstallContainerArgs args = (InstallContainerArgs)arguments; args.EnvModel.TelerikKey = this._generator.Generate(); }
public PipelineStartInfo([NotNull] ProcessorArgs processorArgs, [NotNull] List <Step> steps, [CanBeNull] IPipelineController pipelineController = null) { Assert.ArgumentNotNull(processorArgs, nameof(processorArgs)); Assert.ArgumentNotNull(steps, nameof(steps)); ProcessorArgs = processorArgs; PipelineController = pipelineController; _Steps = steps; }
public PipelineStartInfo([NotNull] ProcessorArgs processorArgs, [NotNull] List <Step> steps, [CanBeNull] IPipelineController pipelineController = null) { Assert.ArgumentNotNull(processorArgs, "processorArgs"); Assert.ArgumentNotNull(steps, "steps"); this.ProcessorArgs = processorArgs; this.PipelineController = pipelineController; this.Steps = steps; }
protected override void ProcessOptimize(ProcessorArgs args) { var mediaPath = args.InputStream.MediaItem.MediaPath; if (IsExcluded(mediaPath)) { args.AbortPipeline(); } }
protected override void Process(ProcessorArgs args) { var download = (DownloadArgs)args; foreach (var link in download.Links) { download.FileNames[link] = WebRequestHelper.GetFileName(link, download.Cookies); } }
public Processor(ProcessorArgs processorArgs) { ProcessorArgs = processorArgs; // ExternalTools = new ExternalTools(ProcessorArgs.ConfigurationMain.Paths); FileExecution = new FileExecution(ExternalTools); FilePreparation = new FilePreparation(ExternalTools); FileInformation = new FileInformation(); }
protected override void Process([NotNull] ProcessorArgs procArgs) { string command = GetCommand(procArgs); string executionFolder = GetExecutionFolder(procArgs); this._logger = GetLogger(procArgs); RunCommand(executionFolder, command); }
protected override void Process([NotNull] ProcessorArgs arguments) { InstallContainerArgs args = (InstallContainerArgs)arguments; string licensePath = Path.Combine(args.Destination, "license.xml"); if (FileSystem.FileSystem.Local.File.Exists(licensePath)) { args.EnvModel.SitecoreLicense = this.converter.Convert(licensePath); } }
protected override void Process([NotNull] ProcessorArgs args) { Assert.ArgumentNotNull(args, "args"); DeleteContainersArgs deleteArgs = (DeleteContainersArgs)args; Assert.ArgumentNotNull(deleteArgs, "deleteArgs"); FileSystem.FileSystem.Local.Directory.DeleteIfExists(deleteArgs.DestinationFolder); }
protected override void Process([NotNull] ProcessorArgs arguments) { Assert.ArgumentNotNull(arguments, "arguments"); InstallContainerArgs args = (InstallContainerArgs)arguments; if (args.EnvModel.KeyExists(Key)) { args.EnvModel[Key] = this._generator.Generate(); } }
/// <summary> /// Optimizes a media stream and returns the optimized result. The original stream is closed if processing is successful. /// Returns null if processing was unsuccessful. /// </summary> public virtual MediaStream Process(MediaStream stream, MediaOptions options) { Assert.ArgumentNotNull(stream, nameof(stream)); Assert.ArgumentNotNull(options, nameof(options)); if (!stream.AllowMemoryLoading) { Log.Error($"Dianoga: Could not resize image as it was larger than the maximum size allowed for memory processing. Media item: {stream.MediaItem.Path}", this); return(null); } //Run optimizer based on extension var sw = new Stopwatch(); sw.Start(); var result = new ProcessorArgs(stream, options); try { CorePipeline.Run("dianogaOptimize", result); } catch (Exception exception) { Log.Error($"Dianoga: Unable to optimize {stream.MediaItem.MediaPath} due to a processing error! It will be unchanged.", exception, this); return(null); } sw.Stop(); if (result.ResultStream != null && result.ResultStream.CanRead) { if (result.Message.Length > 0) { Log.Info($"Dianoga: messages occurred while optimizing {stream.MediaItem.MediaPath}: {result.Message.Trim()}", this); } var extension = result.Extension ?? stream.Extension; if (result.IsOptimized) { Log.Info($"Dianoga: optimized {stream.MediaItem.MediaPath}.{stream.MediaItem.Extension} [original size: {GetDimensions(options)} {result.Statistics.SizeBefore} bytes] [final size: {result.Statistics.SizeAfter} bytes] [saved {result.Statistics.BytesSaved} bytes / {result.Statistics.PercentageSaved:p}] [Optimized in {sw.ElapsedMilliseconds}ms] [Extension {extension}]", this); } return(new MediaStream(result.ResultStream, extension, stream.MediaItem)); } if (!string.IsNullOrWhiteSpace(result.Message)) { Log.Warn($"Dianoga: unable to optimize {stream.MediaItem.MediaPath}.{stream.MediaItem.Extension} because {result.Message.Trim()}", this); } // if no message exists that implies that nothing in the dianogaOptimize pipeline acted to optimize - e.g. it's a media type we don't know how to optimize, like PDF. return(null); }
public static void Start(string name, Window owner, ProcessorArgs args, bool?isAsync, Action <WizardArgs> action, Func <WizardArgs> createWizardArgs) { Log.Info($"Wizard pipeline '{name}' starts"); using (new ProfileSection("Start wizard")) { ProfileSection.Argument("name", name); ProfileSection.Argument("owner", owner); ProfileSection.Argument("args", args); WizardPipeline wizardPipeline = Definitions[name]; var isSync = !(isAsync ?? !WinAppSettings.AppSysIsSingleThreaded.Value); if (isSync) { using (var wizard = CreateWizardWindow(wizardPipeline, args, createWizardArgs)) { WindowHelper.ShowDialog(wizard, owner); if (action != null) { var wizardArgs = wizard.WizardArgs; action(wizardArgs); } } } else { var wizard = CreateWizardWindow(wizardPipeline, args, createWizardArgs); if (action != null && !flag) { flag = true; wizard.Closed += (o, e) => { try { var wizardArgs = wizard.WizardArgs; action(wizardArgs); flag = false; } finally { wizard.Dispose(); } }; } else { wizard.Closed += (obj, e) => wizard.Dispose(); } WindowHelper.ShowWindow(wizard, owner); } } }
protected override void Process([NotNull] ProcessorArgs arguments) { Assert.ArgumentNotNull(arguments, "arguments"); InstallContainerArgs args = (InstallContainerArgs)arguments; if (string.IsNullOrEmpty(args.EnvModel.SqlAdminPassword)) { args.EnvModel.SqlAdminPassword = this._generator.Generate(); } }
protected override void Process(ProcessorArgs processorArgs) { var args = (SetupArgs)processorArgs; var profile = ProfileManager.Profile ?? new Profile(); profile.ConnectionString = args.ConnectionString; profile.InstancesFolder = args.InstancesRootFolderPath; profile.License = args.LicenseFilePath; profile.LocalRepository = args.LocalRepositoryFolderPath; ProfileManager.SaveChanges(profile); }
protected override void Process([NotNull] ProcessorArgs arguments) { InstallContainerArgs args = (InstallContainerArgs)arguments; SIM.FileSystem.FileSystem.Local.Directory.Copy(args.FilesRoot, args.Destination, true); if (FileSystem.FileSystem.Local.File.Exists(args.EnvModel.SitecoreLicense)) { string licensePath = Path.Combine(args.Destination, "license.xml"); FileSystem.FileSystem.Local.File.Copy(args.EnvModel.SitecoreLicense, licensePath); } }
protected override void Process([NotNull] ProcessorArgs args) { Install9Args arguments = (Install9Args)args; if (arguments.Tasker.UnInstall || arguments.ScriptsOnly) { this.Skip(); return; } arguments.UnInstallDataPath = arguments.Tasker.SaveUninstallData(ApplicationManager.UnInstallParamsFolder); }
protected override void Process([CanBeNull] ProcessorArgs args) { var tempFolder = ApplicationManager.TempFolder; if (!Directory.Exists(tempFolder)) { Directory.CreateDirectory(tempFolder); } File.WriteAllText(Path.Combine(tempFolder, "agreement-accepted.txt"), @"agreement accepted"); }
protected override void Process([NotNull] ProcessorArgs arguments) { Assert.ArgumentNotNull(arguments, nameof(arguments)); InstallContainerArgs args = (InstallContainerArgs)arguments; Assert.ArgumentNotNull(args, nameof(args)); IEnumerable <string> hosts = GetHostNames(args); DoUpdate(hosts); }
public override void Process(ProcessorArgs args) { RequestHandler resolvedHandler = args.ResolvedHandler; if (resolvedHandler == null) { throw new ArgumentException("args.ResolvedHandler"); } if (resolvedHandler.PostmortemRevertValue(args.ResultUrl, args.OriginalUrl, args.ClipboardEvent)) { ClipboardManager.SetValue(args.OriginalUrl, true); } }
internal static IRelease GetRelease(ProcessorArgs args) { args.WriteLine("Downloading metadata..."); var kernelVersion = args.SitecoreVersion; var versionName = GetVersionName(kernelVersion); var version = GetVersion(versionName); var releaseName = GetReleaseName(kernelVersion); var release = GetRelease(version, releaseName); return(release); }
public override void Process(ProcessorArgs args) { RequestHandler resolvedHandler = args.ResolvedHandler; if (resolvedHandler == null) { throw new ArgumentException("args.ResolvedHandler"); } if (!resolvedHandler.PostExecute(args.ResultUrl, args.ClipboardEvent)) { this.HandleErrorAndAbortPipeline(args, this.NotFoundTrayIcon); } }
protected override string GetDestination(ProcessorArgs arguments) { DeleteContainersArgs args = (DeleteContainersArgs)arguments; string destinationFolder = args?.DestinationFolder; if (string.IsNullOrEmpty(destinationFolder)) { throw new InvalidOperationException($"destinationFolder is null or empty in {this.GetType().Name}"); } return(destinationFolder); }
public Pipeline([NotNull] PipelineDefinition pipelineDefinition, [NotNull] ProcessorArgs args, [CanBeNull] IPipelineController controller = null, bool isAsync = true) { Assert.ArgumentNotNull(pipelineDefinition, nameof(pipelineDefinition)); Assert.ArgumentNotNull(args, nameof(args)); Controller = controller; PipelineDefinition = pipelineDefinition; Title = pipelineDefinition.Title; _Steps = Step.CreateSteps(PipelineDefinition.Steps, args, controller); IsAsync = isAsync; // Storing args for restarting pipeline ProcessorArgs = args; }
public override void Process(ProcessorArgs args) { NotifyIconManager notifyIconManager = NotifyIconManager.ActualManager; if (args.ClipboardEvent) { args.CurrentNotifyIconChangerClient = notifyIconManager.GlobalNotifyIconChangerClient; } else { args.CurrentNotifyIconChangerClient = args.OriginatorIsGlobalIcon ? notifyIconManager.GlobalNotifyIconChangerClient : notifyIconManager.NotifyIconChangerClient; } }
public override void Process(ProcessorArgs args) { if (!args.ShouldBeShorted && !args.OnlyShorteningRequired) { return; } string outputString; if (!ShortenerManager.TryShorterUrl(args.ResultUrl, out outputString)) { this.HandleErrorAndAbortPipeline(args, this.ErrorTrayIcon); } else { args.ResultUrl = outputString; } }
public override void Process(ProcessorArgs args) { RequestHandler resolvedHandler; if (!RequestHandlerChief.TryToResolveHandler(args, out resolvedHandler)) { if (!args.ClipboardEvent) { this.HandleErrorAndAbortPipeline(args, this.NotFoundTrayIcon); } else { args.Abort(); } return; } args.ResolvedHandler = resolvedHandler; }
public override void Process(ProcessorArgs args) { RequestHandler resolvedHandler = args.ResolvedHandler; if (resolvedHandler == null) { throw new ArgumentException("args.ResolvedHandler"); } string result; var notifyIconManager = Factory.ActualFactory.GetNotifyIconManager(); args.CurrentNotifyIconChangerClient.SetIcon(notifyIconManager.InProgressTrayIcon, 10000000); if (!resolvedHandler.TryProcess(args.ResultUrl, out result)) { this.HandleErrorAndAbortPipeline(args, this.ErrorTrayIcon); return; } args.ShouldBeShorted = resolvedHandler.IsShorterEnabled; args.ResultUrl = result; }
public override void Process(ProcessorArgs args) { if (args.ClipboardEvent) { if (args.PredefinedClipboardValue.IsNullOrEmpty()) { args.Abort(); return; } args.ResultUrl = args.PredefinedClipboardValue; } else { string currentValue = Factory.ActualFactory.GetClipboardProvider().GetValue(); if (currentValue.IsNullOrEmpty()) { this.HandleErrorAndAbortPipeline(args, this.NotFoundTrayIcon); } else { args.ResultUrl = currentValue; } } }
public override void Process(ProcessorArgs args) { ClipboardManager.SetValue(args.ResultUrl, true); }
public override void Process(ProcessorArgs args) { args.OriginalUrl = args.ResultUrl; }