/// <summary>
/// Execute the PowerShell script that creates a manifest of the root package folder.
/// </summary>
/// <param name="packageData"></param>
private static bool ExecuteManifestScript(PackageData packageData)
{
Logger.Log("Beginning execution of Manifest script for the " + packageData.PackageName + " package");
using (PowerShell PowerShellInstance = PowerShell.Create())
{
PowerShellInstance.AddScript(PackageManager.Properties.Resources.Get_Md5Manifest);
PowerShellInstance.AddParameter("Target", packageData.RootPackageFolder);
PowerShellInstance.AddParameter("Recurse", true);
Collection <PSObject> PSOutput = PowerShellInstance.Invoke();
PSObject outputItem = PSOutput.FirstOrDefault();
if (outputItem != null)
{
string outputManifest = packageData.RootPackageFolder + Path.DirectorySeparatorChar + packageData.PackageName + ".manfiest.json";
File.Create(outputManifest).Dispose();
using (var sw = new StreamWriter(outputManifest, true))
{
sw.Write(outputItem.BaseObject.ToString());
}
}
else
{
Logger.Log("Failed to create a manifest file for the package");
return(false);
}
}
Logger.Log("Manifest file created successfully");
return(true);
}
/// <summary>
/// Reads the input file to the program. This is where paramaters are provided for creating the package.
/// </summary>
/// <param name="inputFile"> Path to the input file. </param>
/// <param name="packageData"> Data object for the package. </param>
private static void ReadInputFileData(string inputFile, PackageData packageData)
{
try
{
Logger.Log("Reading input file");
using (var streamReader = new StreamReader(new FileStream(inputFile, FileMode.Open, FileAccess.Read)))
{
while (!streamReader.EndOfStream)
{
dynamic inputJson = JsonConvert.DeserializeObject(streamReader.ReadToEnd());
packageData.PackageName = inputJson.PACKAGE_NAME;
packageData.Date = inputJson.DATE;
packageData.BusinessItem = inputJson.BUSINESS_ITEM;
packageData.Prerequisites = inputJson.PREREQUISITES.ToObject <string[]>();
packageData.PackageDescription = inputJson.PACKAGE_DESCRIPTION;
}
}
Logger.Log("Finished reading input file");
}
catch (Exception e)
{
FatalError("Fatal Error reading input file: " + e.Message);
}
}
/// <summary>
/// Sets the booleans that determine what key items are going to be a part of the package being created.
/// </summary>
/// <param name="packageData"> The data object for the package </param>
private static void SetPackageContentBooleans(PackageData packageData)
{
packageData.HasForms = !IsDirectoryEmpty(packageData.InputInstallFormsFolder);
packageData.HasFirmware = !IsDirectoryEmpty(packageData.InputInstallFirmwareFolder);
packageData.HasFormsRollback = !IsDirectoryEmpty(packageData.InputRollbackFormsFolder);
packageData.HasFirmwareRollback = !IsDirectoryEmpty(packageData.InputRollbackFirmwareFolder);
}
static void Main(string[] args)
{
Logger.Log("Package Manager Start");
PackageData packageData = new PackageData();
packageData.InputInstallFormsFolder = CreateFolder(CurrentFolder + Path.DirectorySeparatorChar, "install-forms");
packageData.InputInstallFirmwareFolder = CreateFolder(CurrentFolder + Path.DirectorySeparatorChar, "install-firmware");
packageData.InputRollbackFormsFolder = CreateFolder(CurrentFolder + Path.DirectorySeparatorChar, "rollback-forms");
packageData.InputRollbackFirmwareFolder = CreateFolder(CurrentFolder + Path.DirectorySeparatorChar, "rollback-firmware");
if (args.Length != 1)
{
ShowUsage();
CreateSampleInputFile();
FatalError("This program requires a json file passed as it's only argument. An example input file has been provided in the " +
"same directory from whence you ran the executable. Please try again");
}
string inputFile = args[0];
bool inputFileIsValid = ValidateInputFile(inputFile, ".json");
bool inputFoldersAreValid = ValidateInputFolders(packageData);
if (!inputFileIsValid || !inputFoldersAreValid)
{
ShowUsage();
CreateSampleInputFile();
FatalError("The input file or input folders were not in a valid state. An example input file has been provided in the" +
"same directory from whence you ran the executable. Please try again.");
}
ReadInputFileData(inputFile, packageData);
SetPackageContentBooleans(packageData);
CreatePackageFolders(packageData);
FileBuilder fileBuilder = new FileBuilder(packageData);
BuildPackageFiles(fileBuilder, packageData);
if (packageData.HasRollback)
{
HandleRollbackItems(packageData, fileBuilder);
}
ManifestPackage(packageData);
CleanExecutableDirectory(packageData);
Logger.Log("Package Manager End");
Logger.Dispose();
}
/// <summary>
/// Handle the creation of the file manifest for the package.
/// </summary>
/// <param name="packageData"> The data object for the package </param>
private static void ManifestPackage(PackageData packageData)
{
if (ExecuteManifestScript(packageData))
{
Logger.Log("Manifest created successfully");
}
else
{
Console.WriteLine("Warning, the manifest file for this package was not able to be generated. All other package " +
"items were created successfully.");
Console.WriteLine();
Console.WriteLine("Press any key to continue");
Console.ReadKey();
}
}
/// <summary>
/// Build all of the various files associated with a package.
/// </summary>
/// <param name="fileBuilder"> The file builder object, which contains methods for building each file type. </param>
/// <param name="packageData"> The data object for the package </param>
private static void BuildPackageFiles(FileBuilder fileBuilder, PackageData packageData)
{
string rootReadMe = CreateFile(packageData.RootPackageFolder, "readme.md");
string changeLogFile = CreateFile(packageData.RootPackageFolder, "changelog.txt");
string verifyReadMe = CreateFile(packageData.VerifyFolder, "readme.md");
string touchScript = CreateFile(packageData.ScriptsFolder, "touch.cmd");
string installReadMe = CreateFile(packageData.InstallFolder, "readme.md");
string installScript = CreateFile(packageData.InstallFolder, "install.cmd");
fileBuilder.BuildRootReadMe(rootReadMe);
fileBuilder.BuildChangeLog(changeLogFile);
fileBuilder.BuildVerifyReadMe(verifyReadMe);
fileBuilder.BuildTouchScript(touchScript);
fileBuilder.BuildInstallReadMe(installReadMe);
fileBuilder.BuildInstallScript(installScript);
}
/// <summary>
/// Clean up the folder where the executable resides by getting rid of any remaining input folders.
/// </summary>
/// <param name="packageData"> The data object for the package </param>
private static void CleanExecutableDirectory(PackageData packageData)
{
if (Directory.Exists(packageData.InputInstallFormsFolder))
{
Directory.Delete(packageData.InputInstallFormsFolder);
}
if (Directory.Exists(packageData.InputInstallFirmwareFolder))
{
Directory.Delete(packageData.InputInstallFirmwareFolder);
}
if (Directory.Exists(packageData.InputRollbackFormsFolder))
{
Directory.Delete(packageData.InputRollbackFormsFolder);
}
if (Directory.Exists(packageData.InputRollbackFirmwareFolder))
{
Directory.Delete(packageData.InputRollbackFirmwareFolder);
}
}
/// <summary>
/// Creates the core folders for the package.
/// </summary>
/// <param name="packageData"> The data object for the package </param>
private static void CreatePackageFolders(PackageData packageData)
{
packageData.RootPackageFolder = CreateFolder(CurrentFolder, packageData.PackageName);
packageData.InstallFolder = CreateFolder(packageData.RootPackageFolder, "install");
packageData.ScriptsFolder = CreateFolder(packageData.RootPackageFolder, "scripts");
packageData.VerifyFolder = CreateFolder(packageData.RootPackageFolder, "verify");
if (packageData.HasForms)
{
packageData.InstallForms = GetFolderFiles(packageData.InputInstallFormsFolder);
packageData.FinalInstallFormsFolder = packageData.InstallFolder + "\\Forms";
Directory.Move(packageData.InputInstallFormsFolder, packageData.FinalInstallFormsFolder);
}
if (packageData.HasFirmware)
{
packageData.InstallFirmware = GetFolderFiles(packageData.InputInstallFirmwareFolder);
packageData.FinalInstallFirmwareFolder = packageData.InstallFolder + "\\Firmware";
Directory.Move(packageData.InputInstallFirmwareFolder, packageData.FinalInstallFirmwareFolder);
}
}
/// <summary>
/// Handles all items related to a rollback, if the package has one.
/// </summary>
/// <param name="packageData"> The data object for the package </param>
/// <param name="fileBuilder"> The file building object, containing methods to build each file type for the package </param>
private static void HandleRollbackItems(PackageData packageData, FileBuilder fileBuilder)
{
packageData.RollbackFolder = CreateFolder(packageData.RootPackageFolder, "rollback");
string rollbackReadMe = CreateFile(packageData.RollbackFolder, "readme.md");
string rollbackScript = CreateFile(packageData.RollbackFolder, "rollback.cmd");
if (packageData.HasFormsRollback)
{
packageData.RollbackForms = GetFolderFiles(packageData.InputRollbackFormsFolder);
packageData.FinalRollbackFormsFolder = packageData.RollbackFolder + "\\Forms";
Directory.Move(packageData.InputRollbackFormsFolder, packageData.FinalRollbackFormsFolder);
}
if (packageData.HasFirmwareRollback)
{
packageData.RollbackFirmware = GetFolderFiles(packageData.InputRollbackFirmwareFolder);
packageData.FinalRollbackFirmwareFolder = packageData.RollbackFolder + "\\Firmware";
Directory.Move(packageData.InputRollbackFirmwareFolder, packageData.FinalRollbackFirmwareFolder);
}
fileBuilder.BuildRollbackReadMe(rollbackReadMe);
fileBuilder.BuildRollbackScript(rollbackScript);
}
public FileBuilder(PackageData packageData)
{
Logger = Logger.LoggerInstance;
PackageData = packageData;
}
/// <summary>
/// Check's the validity of the input folders for the program. Forgive me for this boolean logic.
/// </summary>
/// <param name="packageData"> The data object for the package </param>
/// <returns> True or false, true if things are good, false if they aren't. </returns>
private static bool ValidateInputFolders(PackageData packageData)
{
return(Directory.Exists(packageData.InputInstallFormsFolder) && Directory.Exists(packageData.InputRollbackFormsFolder) &&
Directory.Exists(packageData.InputInstallFirmwareFolder) && Directory.Exists(packageData.InputRollbackFirmwareFolder) &&
(!IsDirectoryEmpty(packageData.InputInstallFormsFolder) || !IsDirectoryEmpty(packageData.InputInstallFirmwareFolder)));
}
