public static PackageInfo GetPackageManifest(string path) { PackageInfo package = new PackageInfo(); XmlDocument doc = new XmlDocument(); doc.Load(path); XmlNode root = doc.DocumentElement; XmlNodeList xnList = doc.SelectNodes("sageframe/packages/package"); foreach (XmlNode xn in xnList) { package.Description = xn["description"].InnerXml.ToString(); package.Version = xn.Attributes["version"].InnerText.ToString(); package.OwnerName = xn["owner"].ChildNodes[0].InnerXml.ToString(); package.Organistaion = xn["owner"].ChildNodes[1].InnerXml.ToString(); package.URL = xn["owner"].ChildNodes[2].InnerXml.ToString(); package.Email = xn["owner"].ChildNodes[3].InnerXml.ToString(); package.ReleaseNotes = xn["releasenotes"].InnerXml.ToString(); package.License = xn["license"].InnerXml.ToString(); } return package; }
public Package(string name, PackageInfo info, PackageStatus status) { Name = name; Id = (info != null ? info.PackageId : null); Info = info; Status = status; }
private static void WritePackageDetails(XmlWriter writer, List<FileDetails> selectedResxFiles,PackageInfo package) { writer.WriteStartElement("package"); writer.WriteAttributeString("name", package.PackageName); writer.WriteAttributeString("type", package.PackageType); writer.WriteAttributeString("version", package.Version); writer.WriteElementString("friendlyname", package.FriendlyName); writer.WriteElementString("description", package.Description); writer.WriteStartElement("owner"); writer.WriteElementString("name", package.OwnerName); writer.WriteElementString("organization",package.Organistaion); writer.WriteElementString("url",""); writer.WriteElementString("email", package.Email); writer.WriteEndElement(); writer.WriteElementString("license", package.License); writer.WriteElementString("releasenotes", package.ReleaseNotes); writer.WriteStartElement("components"); writer.WriteStartElement("component"); writer.WriteAttributeString("type", "CoreLanguage"); writer.WriteStartElement("languagefiles"); writer.WriteElementString("code",""); writer.WriteElementString("displayname", ""); writer.WriteElementString("fallback", ""); WritePackageResources(writer,selectedResxFiles); WritePackageEndElements(writer); }
static void CreateAssembly(PackageInfo package) { // Save the snk file from the embedded resource to the disk so we can use it when we compile using (var resStream = typeof(Program).Assembly.GetManifestResourceStream("GenerateTestPackages." + keyFileName)) { using (var snkStream = File.Create(keyFileName)) { resStream.CopyTo(snkStream); } } var codeProvider = new CSharpCodeProvider(); var compilerParams = new CompilerParameters() { OutputAssembly = Path.GetFullPath(GetAssemblyFullPath(package.FullName)), CompilerOptions = "/keyfile:" + keyFileName }; // Add all the dependencies as referenced assemblies foreach (DependencyInfo dependency in package.Dependencies) { compilerParams.ReferencedAssemblies.Add(GetAssemblyFullPath(dependency.FullName)); } // Create the source code and compile it using CodeDom var generator = new AssemblySourceFileGenerator() { Package = package }; CompilerResults results = codeProvider.CompileAssemblyFromSource(compilerParams, generator.TransformText()); if (results.Errors.HasErrors) { Console.WriteLine(results.Errors[0]); } File.Delete(keyFileName); }
public IPackageInfo LoadFromFolder(string folder) { folder = Path.GetFullPath(folder); var manifest = _fileSystem.LoadFromFile<PackageManifest>(folder, PackageManifest.FILE); var package = new PackageInfo(manifest.Name){ Description = "{0} ({1})".ToFormat(manifest.Name, folder) }; // Right here, this needs to be different package.RegisterFolder(BottleFiles.WebContentFolder, _getContentFolderFromPackageFolder(folder)); package.RegisterFolder(BottleFiles.DataFolder, Path.Combine(folder, BottleFiles.DataFolder)); var binPath = FileSystem.Combine(_applicationFolder, folder, "bin"); var debugPath = FileSystem.Combine(binPath, "debug"); if(_fileSystem.DirectoryExists(debugPath)) { binPath = debugPath; } var assemblyPaths = findCandidateAssemblyFiles(binPath); assemblyPaths.Each(path => { var assemblyName = Path.GetFileNameWithoutExtension(path); if (manifest.AssemblyNames.Contains(assemblyName)) { package.RegisterAssemblyLocation(assemblyName, path); } }); return package; }
/// <summary> /// Deletes all files from a package /// </summary> /// <param name="installed">Insyalled package</param> /// <param name="repositories">Repositories where to find the package</param> private void DeleteFiles(PackageInfo installed, ICollection<string> repositories) { Logger.Log("Deleting installed files... "); var factory = new PackageRepositoryFactory(); IPackage package; var globalRepo = new AggregateRepository(factory, repositories, true); package = globalRepo.FindPackage(installed.Name, SemanticVersion.Parse(installed.Version), true, true); if (package == null) { throw new InexistentPackageException(string.Format("Unable to find package {0} version {1}", installed.Name, installed.Version)); } var fylesystem = new PhysicalFileSystem(installed.InstallationDirectory); fylesystem.DeleteFiles(package.GetFiles(), installed.InstallationDirectory); File.Delete(Path.Combine(installed.InstallationDirectory, installed.Name + "." + installed.Version + ".nupkg")); foreach (var config in Directory.GetFiles(installed.InstallationDirectory, "*.config")) { File.Delete(config); } Logger.Log("Installed files deleted"); }
/// <summary> /// 创建 <see cref="PackageDownloadProgressChangedEventArgs" /> 的新实例(PackageDownloadProgressChangedEventArgs) /// </summary> public PackageDownloadProgressChangedEventArgs(PackageInfo package, long totalBytesToReceive, long bytesReceived, int progressPercentage) : base(progressPercentage, package) { Package = package; TotalBytesToReceive = totalBytesToReceive; BytesReceived = bytesReceived; }
internal Application(PackageInfo pinfo) { name = pinfo.Name; description = pinfo.Description; startupPath = pinfo.GetData ("MonoAddinsRoot"); registryPath = pinfo.GetData ("MonoAddinsRegistry"); testCommand = pinfo.GetData ("MonoAddinsTestCommand"); }
static void ProcessPackage(PackageInfo package) { // Make sure all its dependencies are processed first foreach (var dependency in package.Dependencies) { EnsurePackageProcessed(dependency.FullName.ToString()); } Console.WriteLine("Creating package {0}", package.FullName); CreateAssembly(package); CreatePackage(package); }
/// <summary> /// Removes an installed package from the system /// </summary> /// <param name="info"></param> public void Remove(PackageInfo info, ICollection<string> repositories, Dictionary<string, string> parameters, string optionalScript) { Logger.Log(string.Format("Uninstalling application {0} version {1}", info.Name, info.Version)); ExecuteRemoveScript(info,parameters, optionalScript); DeleteFiles(info,repositories); Logger.Log(string.Format("Uninstalled application {0} version {1}", info.Name, info.Version)); }
public void Process(string filePath, PackageInfo.NamedInstance inst) { var doc = XDocument.Load(filePath); inst.Metadata = new PackageInfo.MetaData(); var pathToInstall = doc.Root.Element("PathToInstall"); if (pathToInstall != null) { inst.Metadata.FolderToInstall = pathToInstall.Value; } }
/// <summary> /// Installs the specified package into the specified directory /// </summary> /// <param name="info"></param> public void Install(PackageInfo info, ICollection<string> repositories, Dictionary<string, string> parameters) { Logger.Log(string.Format("Installing application {0} version {1}", info.Name, info.Version)); DownloadPackage(info, repositories); ApplyTransformations(info, null, null); ExecuteInstallScript(info, parameters, null); Logger.Log(string.Format("Installed application {0} version {1}", info.Name, info.Version)); }
/// <summary> /// Installs the package /// </summary> /// <param name="info">Package informations</param> /// <param name="repositories">Repositories to use</param> /// <param name="parameters">parameters to pass to the script</param> /// <param name="installScript">Installation script to execute</param> /// <param name="configFile">Name of the configuration file</param> /// <param name="configTrasform">Configuration transform to apply</param> public void Install(PackageInfo info, ICollection<string> repositories, Dictionary<string, string> parameters, string installScript, string configFile, string configTrasform) { Logger.Log(String.Format("Starting installation of {0} version {1} ... ", info.Name, info.Version)); DownloadPackage(info, repositories); ApplyTransformations(info, configFile, configTrasform); ExecuteInstallScript(info, parameters, installScript); Logger.Log(String.Format("{0} version {1} Installed successfully ", info.Name, info.Version)); }
/// <summary> /// Writes manifest. /// </summary> /// <param name="path">path</param> /// <param name="filename">filename</param> /// <param name="selectedResxFiles">List of object of FileDetails class. </param> /// <param name="package">Objects of PackageInfo class.</param> public static void WriteManifest(string path,string filename,List<FileDetails> selectedResxFiles,PackageInfo package) { XmlWriter writer = XmlWriter.Create(path + @"/" + filename + ".sfe",XMLUtils.GetXmlWriterSettings()); // Write first element writer.WriteStartElement("sageframe"); writer.WriteAttributeString("type", "Package"); writer.WriteAttributeString("version", "1.0.0.1"); writer.WriteStartElement("packages"); WritePackageDetails(writer,selectedResxFiles,package); // close writer writer.Close(); }
static PackageInfo ConvertToPublic(PackageInfoInternal info) { if (info == null) { return null; } var newInfo = new PackageInfo(); newInfo.Name = info.Name; newInfo.Path = info.Path; newInfo.InstallInfo = ConvertToPublic(info.InstallInfo); return newInfo; }
public AssemblyPackageInfo(Assembly assembly) { _manifest = new AssemblyPackageManifestFactory().Extract(assembly); _inner = new Lazy<PackageInfo>(() => { var inner = new PackageInfo(_manifest); var exploder = BottleExploder.GetPackageExploder(new FileSystem()); exploder.ExplodeAssembly(PackageRegistry.GetApplicationDirectory(), assembly, inner); return inner; }); _assembly = assembly; }
internal Badging(FileInfo source, string dump) { this.source = source; this.package = new PackageInfo(); this.application = new ApplicationInfo(); this.activity = new LaunchableActivity(); this.sdkVersion = ""; this.targetSdkVersion = ""; this.usesPermission = new List<string>(); this.densities = new List<int>(); ProcessDump(dump); }
/// <summary> /// Excutes the uninstall script /// </summary> /// <param name="installed">Installed package</param> /// <param name="parameters">Parameters to pass to the script</param> /// <param name="optionalScript">optional additiona script to execute</param> private void ExecuteRemoveScript(PackageInfo installed, Dictionary<string, string> parameters, string optionalScript) { if (optionalScript != null && optionalScript.Trim().Length > 0) { Logger.Log("Executing uninstallation script specified as parameter..."); PowershellHelpers.ExecuteScript(installed.InstallationDirectory, optionalScript, Logger, parameters); return; } if (File.Exists(Path.Combine(installed.InstallationDirectory, "Uninstall.ps1"))) { Logger.Log("Executing uninstall script contained in package ... "); PowershellHelpers.Execute(installed.InstallationDirectory, "Uninstall.ps1", installed.Configuration, Logger, parameters); } }
private IPackageInfo convertToPackage(string directory) { var folder = _fileSystem.GetFullPath(directory); var manifest = _fileSystem.LoadFromFile<HostManifest>(folder, HostManifest.CONTROL, HostManifest.FILE); var package = new PackageInfo(manifest.Name) { Description = "{0} ({1})".ToFormat(manifest.Name, folder) }; package.RegisterFolder("data", FileSystem.Combine(folder, HostManifest.DATA)); package.RegisterFolder("control", FileSystem.Combine(folder, HostManifest.CONTROL)); return package; }
public static async Task<NupkgEntry> OpenNupkgStreamAsync( HttpSource httpSource, PackageInfo package, TimeSpan cacheAgeLimit, Reports reports) { for (int retry = 0; retry != 3; ++retry) { try { using (var data = await httpSource.GetAsync( package.ContentUri, cacheKey: $"nupkg_{package.Id}.{package.Version}", cacheAgeLimit: retry == 0 ? cacheAgeLimit : TimeSpan.Zero, ensureValidContents: stream => EnsureValidPackageContents(stream, package))) { return new NupkgEntry { TempFileName = data.CacheFileName }; } } catch (Exception ex) { var isFinalAttempt = (retry == 2); var message = ex.Message; if (ex is TaskCanceledException) { message = ErrorMessageUtils.GetFriendlyTimeoutErrorMessage(ex as TaskCanceledException, isFinalAttempt, ignoreFailure: false); } if (isFinalAttempt) { reports.Error.WriteLine( $"Error: DownloadPackageAsync: {package.ContentUri}{Environment.NewLine} {message}".Red().Bold()); throw; } else { reports.Information.WriteLine( $"Warning: DownloadPackageAsync: {package.ContentUri}{Environment.NewLine} {message}".Yellow().Bold()); } } } return null; }
public void Execute(IPackage package, string packagePath) { try { var packageInfo = new PackageInfo { Package = package, PackagePath = packagePath }; Container.RegisterInstance<PackageInfo>(packageInfo, new ContainerControlledLifetimeManager()); MainViewModel.ShowDialog(); } catch (Exception exception) { MessageBox.Show(exception.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error); } }
public static IEnumerable<ContentOnlyPackageInfo> FromAssemblies(string applicationDirectory) { var exploder = BottleExploder.GetPackageExploder(new FileSystem()); var assemblies = FubuModuleAttributePackageLoader.FindAssemblies(new string[] {applicationDirectory.AppendPath("bin")}); var list = new List<ContentOnlyPackageInfo>(); foreach (var assembly in assemblies) { var package = new PackageInfo(new PackageManifest()); exploder.ExplodeAssembly(applicationDirectory, assembly, package); package.ForFolder(BottleFiles.WebContentFolder, dir => { list.Add(new ContentOnlyPackageInfo(dir, assembly.GetName().Name)); }); } return list; }
public IPackageInfo LoadFromFolder(string packageDirectory) { packageDirectory = packageDirectory.ToFullPath(); var manifest = _fileSystem.LoadFromFile<PackageManifest>(packageDirectory, PackageManifest.FILE); var package = new PackageInfo(manifest){ Description = "{0} ({1})".ToFormat(manifest.Name, packageDirectory), Dependencies = manifest.Dependencies }; // Right here, this needs to be different registerFolders(packageDirectory, package); var binPath = determineBinPath(packageDirectory); readAssemblyPaths(manifest, package, binPath); return package; }
/// <summary> /// Creates <see cref="BandwidthOverusageRow"/> using <see cref="PackageInfo"/> as a data source. /// </summary> /// <param name="report">Current <see cref="OverusageReport"/> dataset.</param> /// <param name="packageInfo"><see cref="PackageInfo"/> instance.</param> /// <returns><see cref="BandwidthOverusageRow"/> instance.</returns> /// <exception cref="ArgumentNullException">When <paramref name="report"/> or either <paramref name="packageInfo"/> is <code>null</code>.</exception> public static BandwidthOverusageRow CreateFromPackageInfo(OverusageReport report, PackageInfo packageInfo) { if (report == null) { throw new ArgumentNullException("report"); } if (packageInfo == null) { throw new ArgumentNullException("packageInfo"); } BandwidthOverusageRow row = report.BandwidthOverusage.NewBandwidthOverusageRow(); row.HostingSpaceId = packageInfo.PackageId; row.Allocated = packageInfo.BandWidthQuota; row.Used = packageInfo.BandWidth; row.Usage = (row.Used - row.Allocated); return row; }
public static async Task<NupkgEntry> OpenNupkgStreamAsync( HttpSource httpSource, PackageInfo package, TimeSpan cacheAgeLimit, Reports reports) { for (int retry = 0; retry != 3; ++retry) { try { using (var data = await httpSource.GetAsync( package.ContentUri, cacheKey: $"nupkg_{package.Id}.{package.Version}", cacheAgeLimit: retry == 0 ? cacheAgeLimit : TimeSpan.Zero, ensureValidContents: stream => EnsureValidPackageContents(stream, package))) { return new NupkgEntry { TempFileName = data.CacheFileName }; } } catch (Exception ex) { if (retry == 2) { reports.Error.WriteLine( $"Error: DownloadPackageAsync: {package.ContentUri}{Environment.NewLine} {ex.Message}".Red().Bold()); throw; } else { reports.Information.WriteLine( $"Warning: DownloadPackageAsync: {package.ContentUri}{Environment.NewLine} {ex.Message}".Yellow().Bold()); } } } return null; }
private static long CreateExecution(PackageInfo packageInfo, bool use32RuntimeOn64, EnvironmentReference reference, int commandTimeout, SqlConnection connection) { long executionId = 0; string storedProcName = string.Format("{0}.{1}", packageInfo.Parent.Parent.Parent.Name, CREATE_EXECUTION); using (var command = new SqlCommand(storedProcName, connection)) { command.CommandType = CommandType.StoredProcedure; command.CommandTimeout = commandTimeout; command.Parameters.Add(FOLDER_NAME, SqlDbType.NVarChar, 128); command.Parameters.Add(PROJECT_NAME, SqlDbType.NVarChar, 128); command.Parameters.Add(PACKAGE_NAME, SqlDbType.NVarChar, 260); command.Parameters.Add(REFERENCE_ID, SqlDbType.BigInt); command.Parameters.Add(USE32BITRUNTIME, SqlDbType.Bit); command.Parameters.Add(EXECUTION_ID, SqlDbType.Int); command.Parameters[EXECUTION_ID].Direction = ParameterDirection.Output; command.Parameters[FOLDER_NAME].Value = packageInfo.Parent.Parent.Name; command.Parameters[PROJECT_NAME].Value = packageInfo.Parent.Name; command.Parameters[PACKAGE_NAME].Value = packageInfo.Name; if (reference != null) { command.Parameters[REFERENCE_ID].Value = reference.ReferenceId; } command.Parameters[USE32BITRUNTIME].Value = use32RuntimeOn64; command.ExecuteNonQuery(); executionId = long.Parse(command.Parameters[EXECUTION_ID].Value.ToString()); } return executionId; }
internal static async Task<Stream> OpenNuspecStreamFromNupkgAsync(PackageInfo package, Func<PackageInfo, Task<Stream>> openNupkgStreamAsync, IReport report) { using (var nupkgStream = await openNupkgStreamAsync(package)) { try { using (var archive = new ZipArchive(nupkgStream, ZipArchiveMode.Read, leaveOpen: true)) { var entry = archive.GetEntryOrdinalIgnoreCase(package.Id + ".nuspec"); using (var entryStream = entry.Open()) { var nuspecStream = new MemoryStream((int)entry.Length); #if DNXCORE50 // System.IO.Compression.DeflateStream throws exception when multiple // async readers/writers are working on a single instance of it entryStream.CopyTo(nuspecStream); #else await entryStream.CopyToAsync(nuspecStream); #endif nuspecStream.Seek(0, SeekOrigin.Begin); return nuspecStream; } } } catch (InvalidDataException) { var fileStream = nupkgStream as FileStream; if (fileStream != null) { report.WriteLine("The ZIP archive {0} is corrupt", fileStream.Name.Yellow().Bold()); } throw; } } }
private void Subscribe(string masterfile, string masterDic) { string line = ""; FileStream fs = new FileStream(masterfile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite); StreamReader sr = new StreamReader(fs); while (!sr.EndOfStream) { line = sr.ReadLine(); if (!line.StartsWith("#")) { var strs = TypeConverterEx.Split <string>(line); if (strs != null && strs.Length >= 3) { var pckinfo = new PackageInfo(); pckinfo.ModuleName = strs[0].ToUpper(); pckinfo.FID = int.Parse(strs[1]); pckinfo.Format = FileFormat.Text; pckinfo.FileName = strs[2].ToLower(); pckinfo.FileExtension = Path.GetExtension(pckinfo.FileName); pckinfo.Name = Path.GetFileName(pckinfo.FileName); pckinfo.WorkDirectory = masterDic; if (strs.Length == 4) { pckinfo.IOState = EnumHelper.FromString <IOState>(strs[3].ToUpper()); } else { pckinfo.IOState = IOState.OLD; } var module_name = pckinfo.ModuleName.ToUpper(); if (module_name.Contains("DATA")) { pckinfo.Format = FileFormat.Text; if (module_name.Contains("BINARY")) { pckinfo.Format = FileFormat.Binary; } pckinfo.ModuleName = "DATA"; } _MFNameManager.AddInSilence(pckinfo); var pck = Select(pckinfo.ModuleName); if (pck != null) { pck.PackageInfo = pckinfo; pck.FileName = pckinfo.FileName; pck.Clear(); pck.Initialize(); if (!Packages.Keys.Contains(pck.Name)) { Packages.Add(pck.Name, pck); pck.Owner = this; } } } } } fs.Close(); sr.Close(); }
/// <summary> /// 将指定包的文件添加到忽略列表 /// </summary> /// <param name="pkg"></param> void AddPackageToPreserveList(PackageInfo pkg) { if (pkg == null || pkg.Files == null) return; var reserveDic = FileInstaller.PreservedFiles; foreach (var file in pkg.Files) { if (!reserveDic.ContainsKey(file)) { Trace.TraceInformation("添加 {0} 到保持文件列表,因为下载过程中会跳过,所以不可以删除", file); reserveDic.Add(file, null); } } }
/// ----------------------------------------------------------------------------- /// <summary> /// Constructs the LanguageComponentWriter /// </summary> /// <param name="languagePack">Language Package info.</param> /// <param name="basePath">Base Path.</param> /// <param name="files">A Dictionary of files</param> /// <param name="package">Package Info.</param> /// ----------------------------------------------------------------------------- public LanguageComponentWriter(LanguagePackInfo languagePack, string basePath, Dictionary <string, InstallFile> files, PackageInfo package) : base(basePath, files, package) { _Language = LocaleController.Instance.GetLocale(languagePack.LanguageID); _PackageType = languagePack.PackageType; _DependentPackageID = languagePack.DependentPackageID; }
public void StoreCustomData(Mono.PkgConfig.PcFile pcfile, PackageInfo pkg) { }
public bool IsCustomDataComplete(string pcfile, PackageInfo pkg) { return true; }
public SkinPackageWriter(PackageInfo package) : base(package) { _SkinPackage = SkinController.GetSkinByPackageID(package.PackageID); SetBasePath(); }
/// ----------------------------------------------------------------------------- /// <summary> /// Constructs the LanguageComponentWriter /// </summary> /// <param name="language">Language Info.</param> /// <param name="basePath">Base Path.</param> /// <param name="files">A Dictionary of files</param> /// <param name="package">Package Info.</param> /// ----------------------------------------------------------------------------- public LanguageComponentWriter(Locale language, string basePath, Dictionary <string, InstallFile> files, PackageInfo package) : base(basePath, files, package) { _Language = language; _PackageType = LanguagePackType.Core; }