public int Execute() { return(ConsoleTask.Execute(this, console => { console.WriteLine("Getting package information..."); var dirs = SharedOptions.GetDirectories(BasePackage, OurPackage).ToList(); var script = default(InstallScript); console.Write("Calculating diffs... "); using (var prog = new ProgressBar()) { var processor = new MergeProcessor() { SortDependencies = true }; if (!string.IsNullOrEmpty(FirstOfGroup)) { processor.FirstOfGroup.UnionWith(FirstOfGroup.Split(',')); } processor.ProgressChanged += (s, ev) => prog.Report(ev.Progress / 100.0); script = processor.Merge(dirs[0], dirs[1]); } console.WriteLine("Done."); SharedOptions.WritePackage(console, script, Output, MultipleDirectories, CleanOutput); })); }
public async Task <int> Execute(ILogger logger) { return(ConsoleTask.Execute(this, (console) => { console.WriteLine("Getting package information..."); var script = Package.Create(InputFile).Single().Read(); SharedOptions.WritePackage(console, script, Output, MultipleDirectories, CleanOutput); })); }
public int Execute() { return(ConsoleTask.Execute(this, (console) => { console.WriteLine("Getting package information..."); var script = InnovatorPackage.Load(InputFile).Read(); SharedOptions.WritePackage(console, script, Output, MultipleDirectories, CleanOutput); })); }
public int Execute() { return(ConsoleTask.Execute(this, console => { if (!Directory.Exists(InputFile)) { throw new InvalidOperationException(); } })); }
public async static Task <int> ExecuteAsync <T>(T options, Func <ConsoleTask, Task> func, Action <ConsoleTask> config = null) { var task = new ConsoleTask(); config?.Invoke(task); var verb = options.GetType().GetCustomAttributes(typeof(VerbAttribute), true) .OfType <VerbAttribute>() .FirstOrDefault() ?.Name ?? "Task"; verb = System.Globalization.CultureInfo.CurrentCulture.TextInfo.ToTitleCase(verb); try { task.LogWriter?.WriteLine(Parser.Default.FormatCommandLine(options)); task.LogWriter?.WriteLine(); await func.Invoke(task); task.WriteLine(); task.WriteLine(verb + " succeeded"); return(0); } catch (Exception ex) { var flat = ex; if (ex is AggregateException agg) { flat = agg.Flatten(); } task.LogWriter?.WriteLine(); task.LogWriter?.WriteLine(); var errorOutput = task.LogWriter; if (errorOutput == Console.Out) { errorOutput = Console.Error; } errorOutput?.WriteLine(@"{0:hh\:mm\:ss} {1} failed.", task.Elapsed, verb); errorOutput?.WriteLine(); errorOutput?.WriteLine(flat.ToString()); return(-1); } finally { if (task.LogWriter != null && task.LogWriter != Console.Out) { task.LogWriter.Dispose(); } } }
public Task <int> Execute() { return(ConsoleTask.ExecuteAsync(this, async(console) => { console.WriteLine("Connecting to innovator..."); var conn = await this.GetConnection().ConfigureAwait(false); var processor = new InstallProcessor(conn); console.WriteLine("Reading the install package..."); var script = default(InstallScript); if (Path.GetExtension(InputFile) == ".innpkg") { using (var pkg = InnovatorPackage.Load(InputFile)) script = pkg.Read(); } else { var pkg = new ManifestFolder(InputFile); var doc = pkg.Read(out var title); script = await processor.ConvertManifestXml(doc, title).ConfigureAwait(false); } console.Write("Installing package `{0}`...", script.Title); using (var prog = console.Progress()) { var tcs = new TaskCompletionSource <int>(); processor.ProgressChanged += (s, e) => prog.Report(e.Progress / 100.0); processor.ErrorRaised += (s, e) => { tcs.TrySetException(e.Exception); e.RecoveryOption = RecoveryOption.Abort; }; processor.ActionComplete += (s, e) => { if (e.Exception == null) { tcs.TrySetResult(0); } else { tcs.TrySetException(e.Exception); } }; await processor.Initialize(script).ConfigureAwait(false); processor.Install(); await tcs.Task.ConfigureAwait(false); } console.WriteLine("Done."); })); }
public Task <int> Execute() { return(ConsoleTask.ExecuteAsync(this, async(console) => { foreach (var file in GetMatchingFiles(InputFile)) { console.Write("Generating doc for "); console.WriteLine(file); var metadata = PackageMetadataProvider.FromFile(file); var outputPath = Output.Replace("*", CleanFileName(metadata.Title)); var writer = new DocumentationWriter(); var extension = Path.GetExtension(outputPath).ToUpperInvariant().TrimStart('.'); switch (extension) { case "PUML": case "TXT": writer.Format = DiagramFormat.PlantUml; writer.Output = DocumentOutput.Diagram; break; case "SVG": case "PNG": writer.Format = (DiagramFormat)Enum.Parse(typeof(DiagramFormat), extension, true); writer.Output = DocumentOutput.Diagram; break; case "MD": writer.Format = DiagramFormat.PlantUml; writer.Output = DocumentOutput.Markdown; break; } try { using (var stream = File.OpenWrite(outputPath)) await writer.WriteAsync(metadata, stream); } catch (Exception ex) { console.WriteLine("Error documenting " + file); console.WriteLine(ex.ToString()); } } })); }
public int Execute() { return(ConsoleTask.Execute(this, console => { if (string.IsNullOrWhiteSpace(InputFile)) { throw new ArgumentNullException(nameof(InputFile)); } if (string.IsNullOrWhiteSpace(Transform)) { throw new ArgumentNullException(nameof(Transform)); } if (string.IsNullOrWhiteSpace(Output)) { throw new ArgumentNullException(nameof(Output)); } if (!File.Exists(InputFile)) { throw new FileNotFoundException("Input file was not found.", InputFile); } if (!File.Exists(Transform)) { throw new FileNotFoundException("Transform file was not found.", Transform); } var logger = new Logger(console); using (var document = new XmlTransformableDocument()) using (var transformation = new XmlTransformation(Transform, logger)) { document.PreserveWhitespace = true; document.Load(InputFile); var success = transformation.Apply(document); if (success) { document.Save(Output); } else { throw new AggregateException(logger.Exceptions); } } })); }
public Task <int> Execute(ILogger logger) { return(ConsoleTask.ExecuteAsync(this, async(console) => { console.WriteLine("Connecting to innovator..."); var conn = await GetConnection().ConfigureAwait(false); console.WriteLine("Reading input..."); var stream = string.IsNullOrEmpty(InputFile) ? console.ReadInput() : new FileStream(InputFile, FileMode.Open, FileAccess.Read); var cmd = default(Command); if (string.IsNullOrEmpty(SoapAction)) { var input = conn.AmlContext.FromXml(stream); cmd = new Command(input); if (input.Items().Count() > 1) { cmd.WithAction(CommandAction.ApplyAML); } } else { cmd = new Command(stream.AsString()); } console.WriteLine("Calling action..."); var result = (await conn.ApplyAsync(cmd, true, false).ConfigureAwait(false)).AssertNoError(); console.WriteLine("Writing output..."); using (var output = string.IsNullOrEmpty(Output) ? Console.Out : new StreamWriter(Output)) using (var xml = XmlWriter.Create(output)) { result.ToAml(xml); } }, console => { if (string.IsNullOrEmpty(Output)) { console.LogWriter = string.IsNullOrEmpty(LogFile) ? null : new StreamWriter(LogFile); } })); }
public int Execute() { return(ConsoleTask.Execute(this, console => { console.WriteLine("Getting package information..."); var elem = XElement.Load(InputFile); if (RemoveMetadata) { elem.Attribute("created")?.Remove(); elem.Attribute("creator")?.Remove(); elem.Attribute("modified")?.Remove(); } var baseDir = Path.GetDirectoryName(InputFile); foreach (var path in elem.Elements("Path").ToList()) { var fullPath = Path.Combine(baseDir, path.Attribute("path")?.Value); if (!File.Exists(fullPath)) { Console.WriteLine("Removing reference to `{0}`", path.Attribute("path")?.Value); path.Remove(); } } console.WriteLine("Writing file..."); using (var writer = XmlWriter.Create(InputFile, new XmlWriterSettings() { OmitXmlDeclaration = true, Indent = true })) { elem.Save(writer); } })); }
public Task <int> Execute() { return(ConsoleTask.ExecuteAsync(this, async(console) => { console.WriteLine("Connecting to innovator..."); var conn = await this.GetConnection().ConfigureAwait(false); var processor = new ExportProcessor(conn); var refsToExport = default(List <ItemReference>); var checkDependencies = true; console.Write("Identifying items to export... "); if (this.InputFile?.EndsWith(".innpkg", StringComparison.OrdinalIgnoreCase) == true || this.InputFile?.EndsWith(".mf", StringComparison.OrdinalIgnoreCase) == true) { var exportScript = InnovatorPackage.Load(this.InputFile).Read(); refsToExport = exportScript.Lines .Where(l => l.Type == InstallType.Create) .Select(l => l.Reference) .Distinct() .ToList(); } else { var exportQuery = XElement.Parse("<AML><Item type='*' /></AML>"); if (!string.IsNullOrEmpty(this.InputFile)) { exportQuery = XElement.Load(this.InputFile); } var firstItem = exportQuery.XPathSelectElement("//Item[1]"); if (firstItem == null) { throw new Exception("No item nodes could be found"); } var items = default(IEnumerable <XElement>); if (firstItem.Parent == null) { items = new[] { firstItem } } ; else { items = firstItem.Parent.Elements("Item"); } var version = await conn.FetchVersion(true).ConfigureAwait(false); var types = ExportAllType.Types.Where(t => t.Applies(version)).ToList(); var queries = GetQueryies(items, types).ToList(); checkDependencies = items.All(e => e.Attribute("type")?.Value != "*"); using (var prog = console.Progress()) { var toExport = await SharedUtils.TaskPool(30, (l, m) => prog.Report(l / 100.0), queries .Select(q => { var aml = new XElement(q); var levels = aml.Attribute("levels"); if (levels != null) { levels.Remove(); } return (Func <Task <QueryAndResult> >)(() => conn.ApplyAsync(aml, true, false) .ToTask() .ContinueWith(t => new QueryAndResult() { Query = q, Result = t.Result })); }) .ToArray()); refsToExport = toExport.SelectMany(r => { var refs = r.Result.Items() .Select(i => ItemReference.FromFullItem(i, true)) .ToList(); var levels = (int?)r.Query.Attribute("levels"); if (levels.HasValue) { foreach (var iRef in refs) { iRef.Levels = levels.Value; } } return refs; }) .ToList(); } } console.WriteLine("Done."); var script = new InstallScript { ExportUri = new Uri(Url), ExportDb = Database, Lines = Enumerable.Empty <InstallItem>(), Title = Title ?? System.IO.Path.GetFileNameWithoutExtension(Output), Creator = Author ?? Username, Website = string.IsNullOrEmpty(Website) ? null : new Uri(Website), Description = Description, Created = DateTime.Now, Modified = DateTime.Now }; console.Write("Exporting metadata... "); using (var prog = console.Progress()) { processor.ProgressChanged += (s, e) => prog.Report(e.Progress / 100.0); processor.ActionComplete += (s, e) => { if (e.Exception != null) { throw new AggregateException(e.Exception); } }; await processor.Export(script, refsToExport, checkDependencies); } console.WriteLine("Done."); WritePackage(console, script, Output, MultipleDirectories, CleanOutput); })); }
public static void WritePackage(ConsoleTask console, InstallScript script, string output, bool multipleDirectories, bool cleanOutput) { multipleDirectories = multipleDirectories || string.Equals(Path.GetExtension(output), ".mf", StringComparison.OrdinalIgnoreCase); if (cleanOutput) { console.Write("Cleaning output... "); if (multipleDirectories) { var dir = new DirectoryInfo(Path.GetDirectoryName(output)); if (dir.Exists) { Parallel.ForEach(dir.EnumerateFileSystemInfos(), fs => { if (fs is DirectoryInfo di) { di.Delete(true); } else { fs.Delete(); } }); } else { dir.Create(); } } else { File.Delete(output); } console.WriteLine("Done."); } console.Write("Writing package... "); var outputDir = Path.GetDirectoryName(output); if (!Directory.Exists(outputDir)) { Directory.CreateDirectory(outputDir); } switch (Path.GetExtension(output).ToLowerInvariant()) { case ".mf": var manifest = new ManifestFolder(output); manifest.Write(script); break; case ".innpkg": if (multipleDirectories) { using (var pkgFolder = new InnovatorPackageFolder(output)) pkgFolder.Write(script); } else { if (File.Exists(output)) { File.Delete(output); } using (var pkgFile = new InnovatorPackageFile(output)) pkgFile.Write(script); } break; default: throw new NotSupportedException("Output file type is not supported"); } console.WriteLine("Done."); }
public Logger(ConsoleTask console) { _console = console; }
public Task <int> Execute() { return(ConsoleTask.ExecuteAsync(this, async(console) => { console.WriteLine("Connecting to innovator..."); var conn = await this.GetConnection().ConfigureAwait(false); var processor = new ExportProcessor(conn); var refsToExport = default(List <ItemReference>); var checkDependencies = true; if (string.IsNullOrEmpty(this.InputFile)) { var version = await conn.FetchVersion(true).ConfigureAwait(false); var types = ExportAllType.Types.Where(t => t.Applies(version)).ToList(); console.Write("Identifying all metadata items... "); using (var prog = console.Progress()) { var toExport = await SharedUtils.TaskPool(30, (l, m) => prog.Report(l / 100.0), types .Select(t => (Func <Task <IReadOnlyResult> >)(() => conn.ApplyAsync(t.ToString(), true, false).ToTask())) .ToArray()); refsToExport = toExport.SelectMany(r => r.Items()) .Select(i => ItemReference.FromFullItem(i, true)) .ToList(); } console.WriteLine("Done."); checkDependencies = false; } else { throw new NotSupportedException("Input package is not supported"); } var script = new InstallScript { ExportUri = new Uri(Url), ExportDb = Database, Lines = Enumerable.Empty <InstallItem>(), Title = Title ?? System.IO.Path.GetFileNameWithoutExtension(Output), Creator = Author ?? Username, Website = string.IsNullOrEmpty(Website) ? null : new Uri(Website), Description = Description, Created = DateTime.Now, Modified = DateTime.Now }; console.Write("Exporting metadata... "); using (var prog = console.Progress()) { processor.ProgressChanged += (s, e) => prog.Report(e.Progress / 100.0); processor.ActionComplete += (s, e) => { if (e.Exception != null) { throw new AggregateException(e.Exception); } }; await processor.Export(script, refsToExport, checkDependencies); } console.WriteLine("Done."); WritePackage(console, script, Output, MultipleDirectories, CleanOutput); })); }