示例#1
0
 public bool Extract(
     SolutionPackager_PackageType packageType,
     string mappingFile,
     bool?allowWrite,
     bool?allowDelete,
     bool clobber,
     string sourceLoc,
     bool localize,
     bool treatWarningsAsErrors)
 {
     return(Execute(
                SolutionPackager_Action.Extract,
                packageType,
                allowWrite,
                allowDelete,
                clobber,
                SolutionPackager_ErrorLevel.Verbose,
                mappingFile,
                true,
                Log,
                sourceLoc,
                localize,
                treatWarningsAsErrors
                ));
 }
        public bool ExtractSolution(
            string solutionPackager,
            string solutionFile,
            string folder,
            SolutionPackager_PackageType packageType,
            string mappingFile,
            string sourceLoc,
            bool localize,
            bool treatWarningsAsErrors,
            string logsDirectory
            )
        {
            Logger.LogVerbose("Unpacking Solution: {0}", solutionFile);

            SolutionXml     solutionXml = new SolutionXml(Logger);
            XrmSolutionInfo info        = solutionXml.GetSolutionInfoFromZip(solutionFile);

            if (info == null)
            {
                throw new Exception("Invalid solution file");
            }

            Logger.LogInformation("Unpacking Solution Name: {0} - Version {1}", info.UniqueName, info.Version);

            SolutionNameGenerator generator = new SolutionNameGenerator();

            string zipFile = new FileInfo(solutionFile).Name;

            string log = string.Empty;

            if (!string.IsNullOrEmpty(logsDirectory))
            {
                log = $"{logsDirectory}\\PackagerLog_{zipFile.Replace(".zip", "")}_{DateTime.Now.ToString("yyyy_MM_dd__HH_mm")}.txt";
            }

            Logger.LogVerbose("log: {0}", log);

            SolutionPackager packager = new SolutionPackager(
                Logger,
                solutionPackager,
                solutionFile,
                folder,
                log
                );

            bool result = packager.Extract(
                packageType,
                mappingFile,
                true,
                true,
                false,
                sourceLoc,
                localize,
                treatWarningsAsErrors);

            return(result);
        }
示例#3
0
 public bool Pack(
     SolutionPackager_PackageType packageType,
     string mappingFile,
     bool treatWarningsAsErrors)
 {
     return(Execute(
                SolutionPackager_Action.Pack,
                packageType,
                null,
                null,
                false,
                SolutionPackager_ErrorLevel.Verbose,
                mappingFile,
                true,
                Log,
                string.Empty,
                false,
                treatWarningsAsErrors));
 }
示例#4
0
        protected bool Execute(
            SolutionPackager_Action action,
            SolutionPackager_PackageType packageType,
            bool?allowWrite,
            bool?allowDelete,
            bool clobber,
            SolutionPackager_ErrorLevel?errorlevel,
            string map,
            bool nologo,
            string log,
            string sourceLoc,
            bool localize,
            bool treatWarningsAsErrors
            )
        {
            StringBuilder arguments = new StringBuilder();

            Logger.LogVerbose("Generating Solution Packager Arguments");

            arguments.Append($" /action:{action.ToString()}");
            arguments.Append($" /zipFile:\"{ZipFile}\"");
            arguments.Append($" /folder:\"{Folder}\"");
            arguments.Append($" /packageType:{packageType.ToString()}");
            if (allowWrite.HasValue)
            {
                if (allowWrite.Value)
                {
                    arguments.Append($" /allowWrite:Yes");
                }
                else
                {
                    arguments.Append($" /allowWrite:No");
                }
            }
            if (allowDelete.HasValue)
            {
                if (allowDelete.Value)
                {
                    arguments.Append($" /allowDelete:Yes");
                }
                else
                {
                    arguments.Append($" /allowDelete:No");
                }
            }
            if (clobber)
            {
                arguments.Append($" /clobber");
            }
            if (errorlevel.HasValue)
            {
                arguments.Append($" /errorlevel:{errorlevel.Value.ToString()}");
            }
            if (!string.IsNullOrEmpty(map))
            {
                arguments.Append($" /map:\"{map}\"");
            }
            if (nologo)
            {
                arguments.Append($" /nologo");
            }
            if (!string.IsNullOrEmpty(log))
            {
                arguments.Append($" /log:\"{log}\"");
            }
            if (!string.IsNullOrEmpty(sourceLoc))
            {
                arguments.Append($" /sourceLoc:\"{sourceLoc}\"");
            }
            if (localize)
            {
                arguments.Append($" /localize");
            }

            Logger.LogInformation("Solution Packager Version: {0}", FileUtilities.GetFileVersion(Packager));
            Logger.LogInformation("Solution Packager Arguments: {0}", arguments.ToString());

            ProcessStartInfo packagerInfo = new ProcessStartInfo()
            {
                FileName               = Packager,
                Arguments              = arguments.ToString(),
                CreateNoWindow         = true,
                WindowStyle            = ProcessWindowStyle.Hidden,
                RedirectStandardOutput = true,
                RedirectStandardError  = true,
                UseShellExecute        = false,
            };

            int exitCode = -1;

            using (Process packagerProcess = new Process())
            {
                packagerProcess.StartInfo           = packagerInfo;
                packagerProcess.OutputDataReceived += PackagerProcess_OutputDataReceived;
                packagerProcess.ErrorDataReceived  += PackagerProcess_ErrorDataReceived;

                Logger.LogVerbose("Invoking SolutionPackager: {0}", Packager);

                bool start = packagerProcess.Start();
                packagerProcess.BeginOutputReadLine();
                packagerProcess.BeginErrorReadLine();

                packagerProcess.WaitForExit(1000 * 60 * 15); //15 minutes

                //Add sleep to allow time for output streams to flush
                Thread.Sleep(5 * 1000);

                exitCode = packagerProcess.ExitCode;

                Logger.LogInformation("SolutionPackager exit code: {0}", exitCode);

                packagerProcess.Close();
            }

            if (warnings)
            {
                Logger.LogWarning("Solution Packager encountered warnings. Check logs for more information.");
            }
            if (errors)
            {
                Logger.LogError("Solution Packager encountered errors. Check logs for more information.");
            }

            if (exitCode != 0)
            {
                return(false);
            }
            else
            {
                if (treatWarningsAsErrors)
                {
                    if (warnings)
                    {
                        return(false);
                    }
                    else
                    {
                        return(true);
                    }
                }
                else
                {
                    return(true);
                }
            }
        }
        public bool PackSolution(
            string solutionPackager,
            string outputFolder,
            string folder,
            SolutionPackager_PackageType packageType,
            bool includeVersionInName,
            string mappingFile,
            bool treatWarningsAsErrors,
            bool incrementReleaseVersion,
            string version,
            string logsDirectory
            )
        {
            Logger.LogVerbose("Packing Solution from: {0}", folder);

            SolutionXml     solutionXml = new SolutionXml(Logger);
            XrmSolutionInfo info        = solutionXml.GetXrmSolutionInfoFromFolder(folder);

            if (info == null)
            {
                throw new Exception("Invalid solution file");
            }

            Logger.LogInformation("Packing Solution Name: {0} - Version {1}", info.UniqueName, info.Version);

            string newVersion;

            if (incrementReleaseVersion)
            {
                Logger.LogVerbose("Incrementing release version");

                int release = Int32.Parse(info.Version.Substring(info.Version.LastIndexOf(".") + 1));
                newVersion = $"{info.Version.Substring(0, info.Version.LastIndexOf(".") + 1)}{release + 1}";

                solutionXml.UpdateSolutionVersion(folder, newVersion);
            }
            else if (!string.IsNullOrEmpty(version))
            {
                Logger.LogInformation("Updating solution version to {0}", version);

                solutionXml.UpdateSolutionVersion(folder, version);

                newVersion = version;
            }
            else
            {
                newVersion = info.Version;
            }

            SolutionNameGenerator generator = new SolutionNameGenerator();

            string zipFile;
            bool   managed = packageType == SolutionPackager_PackageType.Managed;

            if (includeVersionInName)
            {
                zipFile = generator.GetZipName(
                    info.UniqueName,
                    newVersion,
                    managed);
            }
            else
            {
                zipFile = generator.GetZipName(
                    info.UniqueName,
                    string.Empty,
                    managed);
            }
            string zipFilePath = $"{outputFolder}\\{zipFile}";

            Logger.LogVerbose("zipFile: {0}", zipFilePath);

            string log = string.Empty;

            if (!string.IsNullOrEmpty(logsDirectory))
            {
                log = $"{logsDirectory}\\PackagerLog_{zipFile.Replace(".zip", "")}_{DateTime.Now.ToString("yyyy_MM_dd__HH_mm")}.txt";
            }

            Logger.LogVerbose("log: {0}", log);

            SolutionPackager packager = new SolutionPackager(
                Logger,
                solutionPackager,
                zipFilePath,
                folder,
                log
                );

            return(packager.Pack(
                       packageType,
                       mappingFile,
                       treatWarningsAsErrors));
        }