public void AgentSupplyGpiTest() { IGpiA retGpiA = null; Regulus.Serialization.ISerializer serializer = new Regulus.Serialization.Dynamic.Serializer(); IProtocol protocol = ProtocolHelper.CreateProtocol(serializer); Stream cdClient = new Regulus.Remote.Standalone.Stream(); Network.IStreamable peerClient = cdClient; PackageWriter <ResponsePackage> writer = new PackageWriter <ResponsePackage>(serializer); writer.Start(new ReverseStream(cdClient)); Ghost.IAgent agent = new Regulus.Remote.Ghost.Agent(protocol) as Ghost.IAgent; agent.QueryNotifier <IGpiA>().Supply += gpi => retGpiA = gpi; agent.Start(peerClient); writer.ServerToClient(serializer, ServerToClientOpCode.LoadSoul, new Regulus.Remote.PackageLoadSoul() { EntityId = 1, ReturnType = false, TypeId = 1 }); writer.ServerToClient(serializer, ServerToClientOpCode.LoadSoulCompile, new Regulus.Remote.PackageLoadSoulCompile() { EntityId = 1, TypeId = 1, ReturnId = 0, PassageId = 0 }); while (retGpiA == null) { agent.Update(); } agent.Stop(); writer.Stop(); Assert.AreNotEqual(null, retGpiA); }
public User(IStreamable client, IProtocol protocol, object state) { State = state; Stream = client; _Serialize = protocol.GetSerialize(); _EnableLock = new object(); _Peer = client; _Protocol = protocol; _Responses = new System.Collections.Concurrent.ConcurrentQueue <ResponsePackage>(); _Requests = new System.Collections.Concurrent.ConcurrentQueue <RequestPackage>(); _Reader = new PackageReader <RequestPackage>(protocol.GetSerialize()); _Writer = new PackageWriter <ResponsePackage>(protocol.GetSerialize()); _ExternalRequests = new System.Collections.Concurrent.ConcurrentQueue <RequestPackage>(); _SoulProvider = new SoulProvider(this, this, protocol); _Updater = new ThreadUpdater(_AsyncUpdate); }
private static Task WritePackage(PackageWriter writer, Package package, string outputPath, CancellationToken token) { var task = Task.Run(async() => { // execute actual operation in child task var childTask = Task.Factory.StartNew(() => { try { //writer.WriteProgress += WriteProgressUpdate; writer.Version = PackageVersion.V13; writer.Compression = CompressionMethod.LZ4; writer.CompressionLevel = CompressionLevel.MaxCompression; writer.Write(); } catch (Exception) { // ignored because an exception on a cancellation request // cannot be avoided if the stream gets disposed afterwards } }, TaskCreationOptions.AttachedToParent); var awaiter = childTask.GetAwaiter(); while (!awaiter.IsCompleted) { await Task.Delay(0, token); } }, token); return(task); }
public override void OnAssetSaved(string name, object asset, out Dictionary <string, byte[]> userData) { if (m_Data == null) { userData = null; return; } Debug.Log($"Saving MovableBridgeAIData for {name}"); using (var stream = new MemoryStream()) { using (var writer = new PackageWriter(stream)) { writer.Write(kVersion); m_Data.Write(writer); } userData = new Dictionary <string, byte[]> { { kDataKey, stream.ToArray() } }; } var prefab = ToolsModifierControl.toolController.m_editPrefabInfo; ApplyCustomAI(prefab, m_Data); m_Data = null; }
public static bool CreatePackage(string dataRootPath, List <string> inputPaths, string outputPath, List <string> ignoredFiles) { try { if (!dataRootPath.EndsWith(Path.DirectorySeparatorChar.ToString())) { dataRootPath += Path.DirectorySeparatorChar; } var package = new Package(); foreach (var f in inputPaths) { AddFilesToPackage(package, f, dataRootPath, outputPath, ignoredFiles); } DivinityApp.Log($"Writing package '{outputPath}'."); using (var writer = new PackageWriter(package, outputPath)) { WritePackage(writer, package, outputPath); } return(true); } catch (Exception ex) { DivinityApp.Log($"Error creating package: {ex}"); return(false); } }
/// <summary> /// Writes the package. /// </summary> /// <param name="project">The project.</param> /// <param name="filePath">The file path.</param> private static void WritePackage(PackageProject project, string filePath) { using (var writer = new PackageWriter(filePath)) { writer.Initialize(Installer.CreateInstallationContext()); PackageGenerator.GeneratePackage(project, writer); } }
public static async Task <bool> CreatePackage(string dataRootPath, List <string> inputPaths, string outputPath, List <string> ignoredFiles, CancellationToken?token = null) { try { if (token == null) { token = CancellationToken.None; } if (token.Value.IsCancellationRequested) { Log.Here().Warning($"Package cancellation requested."); //return Task.FromCanceled(token.Value); return(false); } if (!dataRootPath.EndsWith(Path.DirectorySeparatorChar.ToString())) { dataRootPath += Path.DirectorySeparatorChar; } var package = new Package(); AppController.Main.UpdateProgressLog("Parsing project folders..."); foreach (var f in inputPaths) { if (token.Value.IsCancellationRequested) { throw new TaskCanceledException("Cancelled package creation."); } AppController.Main.UpdateProgressLog($"Searching folder \"{f}\" for files to add to package."); await AddFilesToPackage(package, f, dataRootPath, outputPath, ignoredFiles, token.Value); } AppController.Main.UpdateProgressLog($"Writing package to \"{outputPath}\""); using (var writer = new PackageWriter(package, outputPath)) { await WritePackage(writer, package, outputPath, token.Value); } Log.Here().Activity($"Package successfully created at {outputPath}"); return(true); } catch (Exception ex) { if (!token.Value.IsCancellationRequested) { Log.Here().Error($"Error creating package: {ex.ToString()}"); } else { Log.Here().Important($"Cancelled creating package: {ex.ToString()}"); } return(false); } }
public GhostSerializer(ISerializer serializer) { _Reader = new PackageReader <ResponsePackage>(serializer); _Writer = new PackageWriter <RequestPackage>(serializer); _Sends = new System.Collections.Concurrent.ConcurrentQueue <RequestPackage>(); _Receives = new System.Collections.Concurrent.ConcurrentQueue <ResponsePackage>(); _ResponseEvent += _Empty; }
public OnlineStage(IPeer peer, AgentCore core, ISerializer serializer) { _Core = core; _Peer = peer; _Reader = new PackageReader <ResponsePackage>(serializer); _Writer = new PackageWriter <RequestPackage>(serializer); _Sends = new Collection.Queue <RequestPackage>(); _Receives = new Collection.Queue <ResponsePackage>(); }
public void Process(AntidotePackagePipelineArgs args) { string packagePath = Path.Combine(Settings.PackagePath, String.Format("{0}.antidote{1}", Path.GetFileNameWithoutExtension(args.AntidotePackageProject.Name), Path.GetExtension(args.AntidotePackageProject.Name))); ISink<PackageEntry> writer = new PackageWriter(packagePath); ITaskOutput output = new DefaultOutput(); writer.Initialize(new SimpleProcessingContext(output)); PackageGenerator.GeneratePackage(args.AntidotePackageProject, writer); Context.ClientPage.ClientResponse.Alert("Antidote package generated"); }
public OnlineStage(Socket socket, AgentCore core) { _Core = core; _Socket = socket; _Reader = new PackageReader<ResponsePackage>(); _Writer = new PackageWriter<RequestPackage>(OnlineStage.LowFps); _Sends = new Collection.Queue<RequestPackage>(); _Receives = new Collection.Queue<ResponsePackage>(); }
public void TestWriteAndRead() { var package = new Package { Magic = "PKGV0005" }; package.Entries.Add(new PackageEntry { Bytes = Encoding.ASCII.GetBytes("Hello world!"), FullPath = "hello_world.txt", }); package.Entries.Add(new PackageEntry { Bytes = Encoding.ASCII.GetBytes("Test"), FullPath = "test.txt", }); // Write IPackageWriter writer = new PackageWriter(); var stream = new MemoryStream(); using (var binaryWriter = new BinaryWriter(stream, Encoding.UTF8, true)) { writer.WriteTo(binaryWriter, package); } // Read stream.Position = 0; var packageReader = new PackageReader { ReadEntryBytes = true }; Package readPackage; using (var binaryReader = new BinaryReader(stream, Encoding.UTF8, true)) { readPackage = packageReader.ReadFrom(binaryReader); } // Verify Assert.AreEqual(package.Magic, readPackage.Magic); Assert.AreEqual(package.Entries.Count, readPackage.Entries.Count); for (var i = 0; i < package.Entries.Count; i++) { var entry = package.Entries[i]; var readEntry = readPackage.Entries[i]; Assert.AreEqual(entry.Bytes, readEntry.Bytes); Assert.AreEqual(entry.Extension, readEntry.Extension); Assert.AreEqual(entry.Length, readEntry.Length); Assert.AreEqual(entry.Offset, readEntry.Offset); } }
public void Ping() { try { byte[] data = PackageWriter.CreatePing(); Stream.Write(data, 0, data.Length); } catch { Disconnect(); } }
public static async Task <bool> CreatePackageAsync(string dataRootPath, List <string> inputPaths, string outputPath, List <string> ignoredFiles, CancellationToken?token = null) { try { if (token == null) { token = CancellationToken.None; } if (token.Value.IsCancellationRequested) { return(false); } if (!dataRootPath.EndsWith(Alphaleonis.Win32.Filesystem.Path.DirectorySeparatorChar.ToString())) { dataRootPath += Alphaleonis.Win32.Filesystem.Path.DirectorySeparatorChar; } var package = new Package(); foreach (var f in inputPaths) { if (token.Value.IsCancellationRequested) { throw new TaskCanceledException("Cancelled package creation."); } await AddFilesToPackageAsync(package, f, dataRootPath, outputPath, ignoredFiles, token.Value); } DivinityApp.Log($"Writing package '{outputPath}'."); using (var writer = new PackageWriter(package, outputPath)) { await WritePackageAsync(writer, package, outputPath, token.Value); } return(true); } catch (Exception ex) { if (!token.Value.IsCancellationRequested) { DivinityApp.Log($"Error creating package: {ex.ToString()}"); } else { DivinityApp.Log($"Cancelled creating package: {ex.ToString()}"); } return(false); } }
protected override async Task OnWrite(PackageWriter writer) { try { if (Saving != null) { await Saving(writer, this); } } catch (Exception ex) { ExceptionThrown = ex; } }
public Peer(Socket client) { _EnableLock = new object(); _Socket = client; _SoulProvider = new SoulProvider(this, this); _Responses = new Regulus.Collection.Queue<ResponsePackage>(); _Requests = new Regulus.Collection.Queue<RequestPackage>(); _Enable = true; _Reader = new PackageReader<RequestPackage>(); _Writer = new PackageWriter<ResponsePackage>(); }
private static void WritePackage(PackageWriter writer, Package package, string outputPath) { try { //writer.WriteProgress += WriteProgressUpdate; writer.Version = PackageVersion.V13; writer.Compression = CompressionMethod.LZ4; writer.CompressionLevel = CompressionLevel.MaxCompression; writer.Write(); } catch (Exception) { // ignored because an exception on a cancellation request // cannot be avoided if the stream gets disposed afterwards } }
public Peer(IPeer client, IProtocol protocol) { _Serialize = protocol.GetSerialize(); _EnableLock = new object(); _Peer = client; _Protocol = protocol; _SoulProvider = new SoulProvider(this, this, protocol); _Responses = new System.Collections.Concurrent.ConcurrentQueue <ResponsePackage>(); _Requests = new System.Collections.Concurrent.ConcurrentQueue <RequestPackage>(); _Enable = true; _Reader = new PackageReader <RequestPackage>(protocol.GetSerialize()); _Writer = new PackageWriter <ResponsePackage>(protocol.GetSerialize()); }
/// <summary> /// Builds the MSI package to the specified filename. /// </summary> /// <param name="filename">The filename of the MSI package.</param> /// <exception cref="ArgumentException">The <paramref name="filename"/> parameter is null or empty.</exception> /// <exception cref="PackageException">A validation error or other platform error occurred</exception> public void Build(string filename) { if (string.IsNullOrEmpty(filename)) { throw new ArgumentException(Resources.Argument_NullOrEmpty, nameof(filename)); } var validator = new PackageValidator(this); validator.Validate(); try { using (var writer = new PackageWriter(this, filename)) writer.Write(); } catch (Exception ex) { throw new PackageException(Resources.Package_PlatformError, ex); } }
/// <summary> /// Generates the package. /// </summary> /// <param name="list">The list.</param> /// <returns></returns> private string GeneratePackage(List <Item> list) { string fullName = Context.User.Profile.FullName; using (new UserSwitcher(Sitecore.Security.Accounts.User.FromName("sitecore\\admin", false))) { Database contentDatabase = Context.ContentDatabase; PackageProject solution = new PackageProject(); solution.Metadata.PackageName = list[0].Name; solution.Metadata.Author = fullName; ExplicitItemSource explicitItemSource = new ExplicitItemSource(); explicitItemSource.Name = list[0].Name; Item[] objArray = list.ToArray(); if (objArray != null && objArray.Length > 0) { list.AddRange(objArray); } foreach (Item obj in list) { explicitItemSource.Entries.Add(new ItemReference(obj.Uri, false).ToString()); } solution.Sources.Add(explicitItemSource); solution.SaveProject = true; string fileName = list[0].Name + "_" + DateTime.Now.ToString("dd_MM_yyyy_hh_mm_ss_fffffff") + ".zip"; string str = Settings.PackagePath + "\\"; using (PackageWriter packageWriter = new PackageWriter(str + fileName)) { Context.SetActiveSite("shell"); packageWriter.Initialize(Installer.CreateInstallationContext()); PackageGenerator.GeneratePackage(solution, packageWriter); Context.SetActiveSite("website"); } return(str + fileName); } }
public override void Process(BuildPackageArgs args) { if (this.AbortIfErrorsDetected(args)) { return; } if (args.PackageFiles.Entries.Count > 0) { args.Package.Sources.Add(args.PackageFiles); } if (args.PackageItems.Entries.Count > 0 || args.PackageSources.Sources.Count > 0) { args.Package.Sources.Add(args.PackageSources); } args.Package.SaveProject = true; try { this.Log.Debug("Generating package '" + args.PackageFilePath + "'...", this); using (new SiteContextSwitcher(SiteContext.GetSite("shell"))) using (new DatabaseSwitcher(Database.GetDatabase("core"))) using (var writer = new PackageWriter(args.PackageFilePath)) { var context = Sitecore.Install.Serialization.IOUtils.SerializationContext; writer.Initialize(Installer.CreateInstallationContext()); PackageGenerator.GeneratePackage(args.Package, writer); } } catch (Exception ex) { args.Errors.Add(ex.GetType().Name, ex.Message); this.Log.Error("Error generating package '" + args.PackageFilePath + "'", ex, this); } }
public override void Execute(CommandContext context) { Assert.ArgumentNotNull(context, "context"); //get current item Item currentItem = context.Items[0]; string currentItemId = currentItem.ID.ToString(); string currentItemName = currentItem.Name; string currentItemDB = currentItem.Database.Name; string currentDateTime = DateTime.UtcNow.ToString("yyyyMMddTHHmmssfff"); IEnumerable <IItemKey> itemKeys = context.Items.Select(x => new ItemKey(x) as IItemKey); string recurseVal = context.Parameters.Get("recurse"); bool recurse = (!string.IsNullOrEmpty(recurseVal) && true.ToString().ToLowerInvariant().CompareTo(recurseVal.ToLowerInvariant()) == 0); if (recurse) { itemKeys = itemKeys.Union(currentItem.Axes.GetDescendants().Select(x => new ItemKey(x) as IItemKey)); } PackageProject project = InstantPackageManager.GetPackageFromItems(itemKeys); string path = Sitecore.Configuration.Settings.PackagePath; string fileName = string.Format("{0}{1}_{2}_{3}_{4}.zip", currentItemName, (recurse ? "-WithSubItems" : ""), currentItemId.Trim(("{}").ToCharArray()), currentItemDB, currentDateTime); string fullPath = path + '\\' + fileName; //refactor this into a different object project = InstantPackageManager.SetMetaData(project); PackageWriter writer = new PackageWriter(fullPath); IProcessingContext processingContext = new SimpleProcessingContext(); writer.Initialize(processingContext); PackageGenerator.GeneratePackage(project, writer); Context.ClientPage.ClientResponse.Download(fullPath); }
/// <summary> /// Executes the specified context. /// Saves a HotPackage project to XML using a naming scheme similar to the one used in the downloader /// </summary> /// <param name="context">The context.</param> public override void Execute(CommandContext context) { Assert.ArgumentNotNull(context, "context"); throw new NotImplementedException(); string currentDateTime = DateTime.UtcNow.ToString("yyyyMMddTHHmmssfff"); string path = Sitecore.Configuration.Settings.PackagePath; string fileName = string.Format("InstantPackage_{0}.xml", currentDateTime); string fullPath = path + '\\' + fileName; InstantPackageManager packageManager = new InstantPackageManager(new PackageSourceDictionary()); PackageProject package = packageManager.GetPackage(); PackageWriter writer = new PackageWriter(fullPath); IProcessingContext processingContext = new SimpleProcessingContext(); writer.Initialize(processingContext); PackageGenerator.GeneratePackage(package, writer); // package.SaveProject(fullPath); }
public override void Execute(CommandContext context) { Assert.ArgumentNotNull(context, "context"); InstantPackageManager packageManager = new InstantPackageManager(new PackageSourceDictionary()); PackageProject package = packageManager.GetPackage(); string currentDateTime = DateTime.UtcNow.ToString(InstantPackageManager.SortableTimeFormat); //possibly obsolete with use of version number. string path = Sitecore.Configuration.Settings.PackagePath; string fileName = string.Format("InstantPackage_{0}-{1}.zip", Sitecore.Context.Site.HostName, currentDateTime); string fullPath = path + '\\' + fileName; //refactor this into a different object package = InstantPackageManager.SetMetaData(package); PackageWriter writer = new PackageWriter(fullPath); IProcessingContext processingContext = new SimpleProcessingContext(); writer.Initialize(processingContext); PackageGenerator.GeneratePackage(package, writer); Context.ClientPage.ClientResponse.Download(fullPath); }
protected override void ProcessRecord() { var fileName = Path; if (!Zip.IsPresent) { PerformInstallAction(() => { if (fileName == null) { //name of the zip file when not defined fileName = $"{Project.Metadata.PackageName}{(string.IsNullOrEmpty(Project.Metadata.Version) ? "" : "-")}{Project.Metadata.Version}{Constants.SolutionExtension}"; } if (!System.IO.Path.IsPathRooted(fileName)) { fileName = FullPackageProjectPath(fileName); } if (!System.IO.Path.HasExtension(fileName)) { fileName = fileName + Constants.SolutionExtension; } if (NoClobber.IsPresent && System.IO.File.Exists(fileName)) { WriteError(typeof(IOException), $"The file '{fileName}' already exists.", ErrorIds.FileAlreadyExists, ErrorCategory.ResourceExists, fileName); } if (ShouldProcess(fileName, "Export package project")) { FileUtil.WriteToFile(fileName, IOUtils.StoreObject(Project)); } }); } else { PerformInstallAction( () => { if (IncludeProject.IsPresent) { Project.SaveProject = true; } if (fileName == null) { //name of the zip file when not defined fileName = $"{Project.Metadata.PackageName}-PS-{Project.Metadata.Version}{Constants.PackageExtension}"; } if (!System.IO.Path.IsPathRooted(fileName)) { fileName = FullPackagePath(fileName); } if (!System.IO.Path.HasExtension(fileName)) { fileName = fileName + Constants.PackageExtension; } if (NoClobber.IsPresent && System.IO.File.Exists(fileName)) { WriteError(typeof(IOException), $"The file '{fileName}' already exists.", ErrorIds.FileAlreadyExists, ErrorCategory.ResourceExists, fileName); } if (ShouldProcess(fileName, "Export package")) { using (var writer = new PackageWriter(fileName)) { writer.Initialize(Installer.CreateInstallationContext()); PackageGenerator.GeneratePackage(Project, writer); } } }); } }
protected override string BuildPackage() { var project = new PackageProject(); var sourceCollection = new SourceCollection <PackageEntry>(); var itemSource = new ExplicitItemSource { SkipVersions = false }; sourceCollection.Add(itemSource); var list = new List <ID>(); foreach (var item in Items) { var i = item; if (list.Any(id => id == i.ID)) { continue; } list.Add(item.ID); var reference = new ItemReference(item.Database.Name, item.Paths.Path, item.ID, LanguageManager.DefaultLanguage, Data.Version.Latest).Reduce(); itemSource.Entries.Add(reference.ToString()); } var fileSource = new ExplicitFileSource(); sourceCollection.Add(fileSource); foreach (var fileName in Files) { if (FileUtil.IsFolder(fileName)) { foreach (var file in Directory.GetFiles(FileUtil.MapPath(fileName), "*", SearchOption.AllDirectories)) { var fileInfo = new FileInfo(file); if ((fileInfo.Attributes & FileAttributes.Hidden) == FileAttributes.Hidden) { continue; } if ((fileInfo.Attributes & FileAttributes.System) == FileAttributes.System) { continue; } fileSource.Entries.Add(file); } } else { fileSource.Entries.Add(fileName); } } project.Sources.Add(sourceCollection); project.Name = "Sitecore Package"; project.Metadata.PackageName = PackageName; project.Metadata.Author = Author; project.Metadata.Version = Version; project.Metadata.Publisher = Publisher; project.Metadata.License = License; project.Metadata.Comment = Comment; project.Metadata.Readme = Readme; project.Metadata.PostStep = PostStep; var context = new SimpleProcessingContext(); var intermediateFile = GetIntermediateFileName(FileName); try { using (var writer = new PackageWriter(PathUtils.MapPath(intermediateFile))) { writer.Initialize(context); PackageGenerator.GeneratePackage(project, writer); } Commit(intermediateFile, FileName); } catch { Cleanup(intermediateFile); throw; } return(FileName); }
public WebdeployProjectEmitter([NotNull] IConfiguration configuration, [NotNull] ITraceService trace, [ItemNotNull, NotNull, ImportMany] IEnumerable <IEmitter> emitters, [NotNull] IFileSystem fileSystem) : base(configuration, trace, emitters, fileSystem) { ISqlGenerator sqlGenerator = new SitecorePackageSqlGenerator(); PackageWriter = new PackageWriter(fileSystem, sqlGenerator, OutputDirectory); }
public static bool RenameSave(string pathToSave, string newName) { try { string baseOldName = Path.GetFileNameWithoutExtension(pathToSave); string baseNewName = Path.GetFileNameWithoutExtension(newName); string output = Path.ChangeExtension(Path.Combine(Path.GetDirectoryName(pathToSave), newName), ".lsv"); using (var reader = new PackageReader(pathToSave)) { Package package = reader.Read(); AbstractFileInfo saveScreenshotImage = package.Files.FirstOrDefault(p => p.Name.EndsWith(".png")); if (saveScreenshotImage != null) { saveScreenshotImage.Name = saveScreenshotImage.Name.Replace(Path.GetFileNameWithoutExtension(saveScreenshotImage.Name), baseNewName); Trace.WriteLine($"Renamed internal screenshot '{saveScreenshotImage.Name}' in '{output}'."); } // Edit the saved date in the meta.lsf to avoid "corruption" messages /* * AbstractFileInfo metaFile = package.Files.FirstOrDefault(p => p.Name == "meta.lsf"); * if (metaFile != null) * { * Resource resource; * System.IO.MemoryStream ms = null; * System.IO.Stream rsrcStream = null; * try * { * rsrcStream = metaFile.MakeStream(); * using (var rsrcReader = new LSFReader(rsrcStream)) * { * resource = rsrcReader.Read(); * * if (resource != null) * { * var saveTimeNode = resource.FindNode("SaveTime"); * * if (saveTimeNode != null) * { * NodeAttribute yearAtt = null; * NodeAttribute monthAtt = null; * NodeAttribute dayAtt = null; * NodeAttribute hoursAtt = null; * NodeAttribute minutesAtt = null; * NodeAttribute secondsAtt = null; * NodeAttribute millisecondsAtt = null; * * saveTimeNode.Attributes.TryGetValue("Year", out yearAtt); * saveTimeNode.Attributes.TryGetValue("Month", out monthAtt); * saveTimeNode.Attributes.TryGetValue("Day", out dayAtt); * saveTimeNode.Attributes.TryGetValue("Hours", out hoursAtt); * saveTimeNode.Attributes.TryGetValue("Minutes", out minutesAtt); * saveTimeNode.Attributes.TryGetValue("Seconds", out secondsAtt); * saveTimeNode.Attributes.TryGetValue("Milliseconds", out millisecondsAtt); * * var time = DateTime.Now; * * Trace.WriteLine($"Year: {yearAtt.Type}"); * Trace.WriteLine($"Month: {monthAtt.Type}"); * Trace.WriteLine($"Day: {dayAtt.Type}"); * Trace.WriteLine($"Hours: {hoursAtt.Type}"); * Trace.WriteLine($"Minutes: {minutesAtt.Type}"); * Trace.WriteLine($"Seconds: {secondsAtt.Type}"); * Trace.WriteLine($"Milliseconds: {millisecondsAtt.Type}"); * * yearAtt.Value = (Byte)time.Year; * monthAtt.Value = (Byte)time.Month; * dayAtt.Value = (Byte)time.Day; * hoursAtt.Value = (Byte)time.Hour; * minutesAtt.Value = (Byte)time.Minute; * secondsAtt.Value = (Byte)time.Second; * millisecondsAtt.Value = (UInt16)time.Millisecond; * * Trace.WriteLine($"Updated SaveTime in save's meta.lsf."); * } * else * { * Trace.WriteLine($"Couldn't find SaveTime node '{String.Join(";", resource.Regions.Values.First().Children.Keys)}'."); * } * * ms = new System.IO.MemoryStream(new byte[4096], true); * var rscrWriter = new LSFWriter(ms, FileVersion.CurrentVersion); * rscrWriter.Write(resource); * ms.Position = 0; * var data = ms.ToArray(); * * if (!ms.CanRead) Trace.WriteLine("MemoryStream is not readable!"); * if(!ms.CanWrite) Trace.WriteLine("MemoryStream is not writable!"); * if(!rsrcStream.CanRead) Trace.WriteLine("rsrcStream is not readable!"); * if(!rsrcStream.CanWrite) Trace.WriteLine("rsrcStream is not writable!"); * * rsrcStream.Write(data, 0, data.Length); * ms.Close(); * } * } * } * finally * { * if (metaFile != null) metaFile.ReleaseStream(); * if (ms != null) ms.Dispose(); * if (rsrcStream != null) rsrcStream.Dispose(); * } * } */ using (var writer = new PackageWriter(package, output)) { writer.Version = Package.CurrentVersion; writer.Compression = LSLib.LS.Enums.CompressionMethod.Zlib; writer.CompressionLevel = CompressionLevel.DefaultCompression; writer.Write(); } File.SetLastWriteTime(output, File.GetLastWriteTime(pathToSave)); File.SetLastAccessTime(output, File.GetLastAccessTime(pathToSave)); return(true); } } catch (Exception ex) { Trace.WriteLine($"Failed to rename save: {ex.ToString()}"); } return(false); }
private static void SymmetricPackageTest(string testName, List <FileInfo> data, PayloadLayoutScheme scheme, bool outputToFile = false, bool precomputed = false) { // Process of writing destroys preKey variable passed in for security // We must copy it to a local variable before reading the package back var preKey = KeyProviders.Alice.SymmetricKeys.ElementAt( StratCom.EntropySupplier.Next(KeyProviders.Alice.SymmetricKeys.Count())); var totalLen = data.Sum(file => file.Length); int expLen = (int)(totalLen * 1.1); TimeSpan enc, dec; using (var ms = new MemoryStream(expLen)) { var sw = Stopwatch.StartNew(); var packageWriter = new PackageWriter(preKey, lowEntropy: false, layoutScheme: scheme); // low entropy = false foreach (var file in data) { packageWriter.AddFile(file.FullName); } if (precomputed) { if (scheme == PayloadLayoutScheme.Simple) { packageWriter.SetPayloadConfiguration(PayloadLayoutConfigurationFactory.CreateSimplePreallocated(data.Count)); } else if (scheme == PayloadLayoutScheme.Frameshift) { packageWriter.SetPayloadConfiguration( PayloadLayoutConfigurationFactory.CreateFrameshiftPrecomputedVariable(data.Count)); } else { throw new InvalidOperationException(); } } packageWriter.Write(ms, false); sw.Stop(); enc = sw.Elapsed; sw.Reset(); ms.Seek(0, SeekOrigin.Begin); if (outputToFile) { using (var fs = new FileStream( IOTestBase.PackageDestinationDirectory.FullName + Path.DirectorySeparatorChar + testName + IOTestBase.PackageExtension, FileMode.Create)) { ms.CopyTo(fs); } ms.Seek(0, SeekOrigin.Begin); } sw.Start(); // Now read it back var readingPackage = PackageReader.FromStream(ms, KeyProviders.Alice); readingPackage.ReadToDirectory(IOTestBase.PackageDestinationDirectory.FullName, true); sw.Stop(); dec = sw.Elapsed; } var megabytes = (double)totalLen / 1024 / 1024; Assert.Pass("{0} ms / {1:N2} MB/s -> {2} ms / {3:N2} MB/s.", enc.Milliseconds, (1000.0 / (double)enc.Milliseconds) * megabytes, dec.Milliseconds, (1000.0 / (double)dec.Milliseconds) * megabytes); }
private void SaveSavegameDatabase() { var packageReader = new PackageReader(storyFilePath.Text); Package package = packageReader.Read(); AbstractFileInfo globalsLsf = package.Files.FirstOrDefault(p => p.Name == "globals.lsf"); if (globalsLsf == null) { MessageBox.Show("The specified package is not a valid savegame (globals.lsf not found)", "Load Failed", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } // Load globals.lsf Resource resource; Stream rsrcStream = globalsLsf.MakeStream(); try { using (var rsrcReader = new LSFReader(rsrcStream)) { resource = rsrcReader.Read(); } } finally { globalsLsf.ReleaseStream(); } // Save story resource and pack into the Story.Story attribute in globals.lsf using (var storyStream = new MemoryStream()) { var storyWriter = new StoryWriter(); storyWriter.Write(storyStream, _story); LSLib.LS.Node storyNode = resource.Regions["Story"].Children["Story"][0]; storyNode.Attributes["Story"].Value = storyStream.ToArray(); } // Save globals.lsf var rewrittenStream = new MemoryStream(); // TODO: Resave using original version var rsrcWriter = new LSFWriter(rewrittenStream, FileVersion.CurrentVersion); rsrcWriter.Write(resource); rewrittenStream.Seek(0, SeekOrigin.Begin); // Re-package global.lsf var rewrittenPackage = new Package(); StreamFileInfo globalsRepacked = StreamFileInfo.CreateFromStream(rewrittenStream, "globals.lsf"); rewrittenPackage.Files.Add(globalsRepacked); List <AbstractFileInfo> files = package.Files.Where(x => x.Name != "globals.lsf").ToList(); rewrittenPackage.Files.AddRange(files); using (var packageWriter = new PackageWriter(rewrittenPackage, $"{storyFilePath.Text}.tmp")) { // TODO: Resave using original version and flags packageWriter.Version = PackageVersion.V13; packageWriter.Compression = CompressionMethod.Zlib; packageWriter.CompressionLevel = CompressionLevel.DefaultCompression; packageWriter.Write(); } rewrittenStream.Dispose(); packageReader.Dispose(); // Create a backup of the original .lsf string backupPath = $"{storyFilePath.Text}.backup"; if (!File.Exists(backupPath)) { File.Move(storyFilePath.Text, backupPath); } else { File.Delete(storyFilePath.Text); } // Replace original savegame with new one File.Move($"{storyFilePath.Text}.tmp", storyFilePath.Text); }
protected override void ProcessRecord() { string fileName = Path; if (!Zip.IsPresent) { PerformInstallAction(() => { if (fileName == null) { //name of the zip file when not defined fileName = string.Format( "{0}{1}{2}.xml", Project.Metadata.PackageName, string.IsNullOrEmpty(Project.Metadata.Version) ? "" : "-", Project.Metadata.Version); } if (!System.IO.Path.IsPathRooted(fileName)) { fileName = FullPackageProjectPath(fileName); } FileUtil.WriteToFile(fileName, IOUtils.StoreObject(Project)); }); } else { PerformInstallAction( () => { if (IncludeProject.IsPresent) { Project.SaveProject = true; } if (fileName == null) { //name of the zip file when not defined fileName = string.Format( "{0}-PS-{1}.zip", Project.Metadata.PackageName, Project.Metadata.Version); } if (!System.IO.Path.IsPathRooted(fileName)) { fileName = FullPackagePath(fileName); } using (var writer = new PackageWriter(fileName)) { writer.Initialize(Installer.CreateInstallationContext()); PackageGenerator.GeneratePackage(Project, writer); } }); } }
protected override void ProcessRecord() { var fileName = Path; if (!Zip.IsPresent) { PerformInstallAction(() => { if (fileName == null) { //name of the zip file when not defined fileName = string.Format( "{0}{1}{2}.xml", Project.Metadata.PackageName, string.IsNullOrEmpty(Project.Metadata.Version) ? "" : "-", Project.Metadata.Version); } if (!System.IO.Path.IsPathRooted(fileName)) { fileName = FullPackageProjectPath(fileName); } if (!System.IO.Path.HasExtension(fileName)) { fileName = fileName + ".xml"; } if (NoClobber.IsPresent && System.IO.File.Exists(fileName)) { WriteError(typeof(IOException), $"The file '{fileName}' already exists.", ErrorIds.FileAlreadyExists, ErrorCategory.ResourceExists, fileName); } if (ShouldProcess(fileName, "Export package project")) { FileUtil.WriteToFile(fileName, IOUtils.StoreObject(Project)); } }); } else { PerformInstallAction( () => { if (IncludeProject.IsPresent) { Project.SaveProject = true; } if (fileName == null) { //name of the zip file when not defined fileName = $"{Project.Metadata.PackageName}-PS-{Project.Metadata.Version}.zip"; } if (!System.IO.Path.IsPathRooted(fileName)) { fileName = FullPackagePath(fileName); } if (!System.IO.Path.HasExtension(fileName)) { fileName = fileName + ".zip"; } if (NoClobber.IsPresent && System.IO.File.Exists(fileName)) { WriteError(typeof(IOException), $"The file '{fileName}' already exists.", ErrorIds.FileAlreadyExists, ErrorCategory.ResourceExists, fileName); } if (ShouldProcess(fileName, "Export package")) { using (var writer = new PackageWriter(fileName)) { writer.Initialize(Installer.CreateInstallationContext()); PackageGenerator.GeneratePackage(Project, writer); } } }); } }
public PackageGenerationResult Generate(Commit commit, bool getAdded = true, bool getUpdated = true) { var result = new PackageGenerationResult(); StringBuilder commitNameBuilder = new StringBuilder(); commitNameBuilder.Append(commit.Name); if (getAdded) { commitNameBuilder.Append("-added"); } if (getUpdated) { commitNameBuilder.Append("-updated"); } commitNameBuilder.Append(".zip"); var commitName = commitNameBuilder.ToString(); var path = PathToFile; result.Name = commitName; result.Path = path; result.Successful = false; var db = _databaseSelector.GetSelectedDataBase(); var document = new PackageProject(); document.Sources.Clear(); var commitUserName = commit.Invoker?.Name; document.Metadata.PackageName = !string.IsNullOrWhiteSpace(commit.Name) ? commit.Name : Constants.Package.DefaultCommitName; document.Metadata.Author = !string.IsNullOrWhiteSpace(commitUserName) ? commitUserName : Constants.Package.DefaultAuthorName; document.Metadata.Publisher = !string.IsNullOrWhiteSpace(User.Current.Name) ? User.Current.Name : Constants.Package.DefaultAuthorName; document.Metadata.Version = Constants.Package.DefaultVersion; var itemsIds = new List <ID>(); if (getAdded) { itemsIds = itemsIds.Union(commit.AddedItems).ToList(); } if (getUpdated) { itemsIds = itemsIds.Union(commit.ChangedItems).ToList(); } var items = new List <Item>(); itemsIds.ForEach(x => { var item = db.GetItem(x); if (item != null) { items.Add(item); } }); ExplicitItemSource source = new ExplicitItemSource(); source.Name = Constants.Package.SourceName; source.SkipVersions = true; foreach (Item item in items) { if (item != null) { source.Entries.Add(new ItemReference(item.Uri, false).ToString()); } } document.Sources.Add(source); document.SaveProject = true; using (new Sitecore.SecurityModel.SecurityDisabler()) { using (var writer = new PackageWriter(MainUtil.MapPath($"{path}{commitName}"))) { Context.SetActiveSite(Constants.Package.ShellSite); writer.Initialize(Installer.CreateInstallationContext()); PackageGenerator.GeneratePackage(document, writer); Context.SetActiveSite(Constants.Package.MainSite); result.Successful = true; } } return(result); }
public void GeneratePackage() { var getReaderProcessor = ReaderTypeProcessor.GetTypeProcessor(this.FileType); var items = getReaderProcessor.ReadFile(this.FilePath); var packageProject = new PackageProject { Metadata = { PackageName = this.PackageName, Author = this.Author, Version = this.Version, Publisher = this.Publisher } }; var packageFileSource = new ExplicitFileSource { Name = "Custom File Source" }; var packageItemSource = new ExplicitItemSource { Name = "Custom Item Source" }; var sourceCollection = new SourceCollection <PackageEntry>(); sourceCollection.Add(packageItemSource); foreach (var item in items) { if (item.ObjectType.ToLower().Equals("item")) { var itemUri = Factory.GetDatabase(Settings.GetSetting("SourceDatabase")).Items.GetItem(item.ObjectPath); if (itemUri != null) { if (item.IncludeSubItem.ToLower().Equals("true")) { sourceCollection.Add(new ItemSource() { SkipVersions = true, Database = itemUri.Uri.DatabaseName, Root = itemUri.Uri.ItemID.ToString() }); } else { packageItemSource.Entries.Add(new ItemReference(itemUri.Uri, false).ToString()); } } } else if (item.ObjectType.ToLower().Equals("file")) { var pathMapped = MainUtil.MapPath(item.ObjectPath); packageFileSource.Entries.Add(pathMapped); } } if (packageFileSource.Entries.Count > 0) { packageProject.Sources.Add(packageFileSource); } if (packageItemSource.Entries.Count > 0 || sourceCollection.Sources.Count > 0) { packageProject.Sources.Add(sourceCollection); } packageProject.SaveProject = true; var packageGeneratorFolder = Settings.GetSetting("PackageGeneratorFolder"); using (var writer = new PackageWriter(MainUtil.MapPath(string.Format("{0}/{1}/{2}.zip", Settings.PackagePath, packageGeneratorFolder, this.PackageName)))) { Context.SetActiveSite("shell"); writer.Initialize(Installer.CreateInstallationContext()); PackageGenerator.GeneratePackage(packageProject, writer); Context.SetActiveSite("website"); } }
public static string GeneratePackage(PackageManifest manifest) { var packageProject = new PackageProject { Metadata = { PackageName = manifest.PackageName, Author = manifest.Author, Version = manifest.Version, Publisher = manifest.Publisher } }; foreach (var fileSource in manifest.Files) { if (fileSource == null || fileSource.Entries == null || fileSource.Entries.Count == 0) { continue; } var packageFileSource = new ExplicitFileSource { Name = "Files" }; packageFileSource.Converter.Transforms.Add( new InstallerConfigurationTransform( new BehaviourOptions(fileSource.InstallMode, fileSource.MergeMode))); foreach (var item in fileSource.Entries) { var pathMapped = MainUtil.MapPath(item.Path); packageFileSource.Entries.Add(pathMapped); } if (packageFileSource.Entries.Count > 0) { packageProject.Sources.Add(packageFileSource); } } foreach (var itemSource in manifest.Items) { if (itemSource == null || itemSource.Entries == null || itemSource.Entries.Count == 0) { continue; } List <Item> items = new List <Item>(); var packageItemSource = new ExplicitItemSource { Name = itemSource.Name }; packageItemSource.Converter.Transforms.Add( new InstallerConfigurationTransform( new BehaviourOptions(itemSource.InstallMode, itemSource.MergeMode))); using (new SecurityDisabler()) { foreach (var item in itemSource.Entries) { var db = ResolveDatabase(item.Database); var itemUri = db.Items.GetItem(item.Path); if (itemUri != null) { items.Add(itemUri); if (item.IncludeChildren) { var paths = Sitecore.StringUtil.Split(itemUri.Paths.Path, '/', true).Where(p => p != null & p != string.Empty).Select(p => "#" + p + "#").ToList(); string allChildQuery = string.Format("/{0}//*", Sitecore.StringUtil.Join(paths, "/")); var children = db.Items.Database.SelectItems(allChildQuery); if (children != null && children.Length > 0) { items.AddRange(children); } } } } foreach (var item in items) { packageItemSource.Entries.Add(new ItemReference(item.Uri, false).ToString()); } } if (packageItemSource.Entries.Count > 0) { packageProject.Sources.Add(packageItemSource); } } packageProject.SaveProject = true; var location = MainUtil.MapPath($"{ Sitecore.Configuration.Settings.PackagePath}/{ manifest.PackageName}"); bool exists = System.IO.Directory.Exists(location); if (!exists) { System.IO.Directory.CreateDirectory(location); } var packagePath = $"{location}/{manifest.PackageName}.zip"; try { using (var writer = new PackageWriter(packagePath)) { using (new SecurityDisabler()) { SiteContext targetSiteContext = SiteContext.GetSite("shell"); using (var context = new SiteContextSwitcher(targetSiteContext)) { writer.Initialize(Installer.CreateInstallationContext()); PackageGenerator.GeneratePackage(packageProject, writer); } } } } catch (Exception ex) { throw new Exception($"Package was not created. Message: {ex.Message}", ex); } return(packagePath); }
protected override void ProcessRecord() { var fileName = Path; if (!Zip.IsPresent) { PerformInstallAction(() => { if (fileName == null) { //name of the zip file when not defined fileName = string.Format( "{0}{1}{2}.xml", Project.Metadata.PackageName, string.IsNullOrEmpty(Project.Metadata.Version) ? "" : "-", Project.Metadata.Version); } if (!System.IO.Path.IsPathRooted(fileName)) { fileName = FullPackageProjectPath(fileName); } if (!System.IO.Path.HasExtension(fileName)) { fileName = fileName + ".xml"; } if (NoClobber.IsPresent && System.IO.File.Exists(fileName)) { var error = String.Format("The file '{0}' already exists.", fileName); WriteError(new ErrorRecord(new IOException(error), error, ErrorCategory.ResourceExists, fileName)); } if (ShouldProcess(fileName, "Export package project")) { FileUtil.WriteToFile(fileName, IOUtils.StoreObject(Project)); } }); } else { PerformInstallAction( () => { if (IncludeProject.IsPresent) { Project.SaveProject = true; } if (fileName == null) { //name of the zip file when not defined fileName = string.Format( "{0}-PS-{1}.zip", Project.Metadata.PackageName, Project.Metadata.Version); } if (!System.IO.Path.IsPathRooted(fileName)) { fileName = FullPackagePath(fileName); } if (!System.IO.Path.HasExtension(fileName)) { fileName = fileName + ".zip"; } if (NoClobber.IsPresent && System.IO.File.Exists(fileName)) { var error = String.Format("The file '{0}' already exists.", fileName); WriteError(new ErrorRecord(new IOException(error), error, ErrorCategory.ResourceExists, fileName)); } if (ShouldProcess(fileName, "Export package")) { using (var writer = new PackageWriter(fileName)) { writer.Initialize(Installer.CreateInstallationContext()); PackageGenerator.GeneratePackage(Project, writer); } } }); } }