/// <summary> /// Loads the configuration from disk. /// </summary> /// <returns>Loaded configuration, if found on disk.</returns> protected override SanitizedConfiguration LoadConfiguration() { if (_config == null) { if (_options.Input == Constants.CurrentDirectory) { _config = base.LoadConfiguration(); } else { string fullPath = Path.GetFullPath(_options.Input); if (Directory.Exists(fullPath) == true) { string configPath = Path.Combine(fullPath, Constants.ConfigFileName); _config = ConfigIO.ReadConfigFile(configPath); if (_config != null) { foreach (Models.Volume volume in _config.Volumes) { volume.InputPath = volume.InputPath.Replace(".", _options.Input); volume.OutputPath = volume.OutputPath.Replace(".", _options.Output); } } } } } return(_config); }
/// <summary> /// Loads the configuration from disk. /// </summary> /// <returns>Loaded configuration, if found on disk.</returns> protected override SanitizedConfiguration LoadConfiguration() { SanitizedConfiguration result = null; if (_options.Input == Constants.CurrentDirectory) { result = base.LoadConfiguration(); } else { string fullPath = Path.GetFullPath(_options.Input); if (Directory.Exists(fullPath) == true) { string configPath = Path.Combine(fullPath, Constants.ConfigFileName); result = ConfigIO.ReadConfigFile(configPath); if (result != null) { foreach (Volume volume in result.Volumes) { volume.InputPath = volume.InputPath.Replace(".", _options.Input); volume.OutputPath = volume.OutputPath.Replace(".", _options.Output); } } else { _commonLogger.NoConfigurationFound(); } } } return(result); }
/// <summary> /// Creates a default configuration. /// </summary> /// <returns>Resulting configuration.</returns> private SanitizedConfiguration CreateDefaultConfig() { SanitizedConfiguration result = new SanitizedConfiguration(); // Config info. result.Name = GetProjectNameDefault(); result.Description = "A Kerboscript project."; result.Archive = FindKSPInstallation(); // Volume info. result.Volumes.Add(new Volume { Index = 1, Name = "boot", InputPath = Constants.DefaultBootVolumePath, OutputPath = Constants.DistBootDirectory, DeployPath = "./boot" }); result.Volumes.Add(new Volume { Index = 2, Name = GetProjectNameDefault(), InputPath = Constants.DefaultVolumePath, OutputPath = Constants.DistDirectory, DeployPath = "./" }); // Scripts. AddDefaultScripts(result); return(result); }
/// <summary> /// Loads all scripts to compiler based on either the configuration or the CLI options. /// </summary> /// <returns>All found scripts.</returns> private List <Kerboscript> LoadScripts() { List <Kerboscript> result = null; _logger.StartScriptLoading(); { if ((_options.Input == Constants.CurrentDirectory && _options.Output == Constants.CurrentDirectory) || ConfigIO.IsDirectory(_options.Input) == true) { if (_options.Output == Constants.CurrentDirectory) { _options.Output = _options.Input; } SanitizedConfiguration config = LoadConfiguration(); if (config != null) { result = _scriptLoader.LoadScriptsFromConfig(config); } } else { result = _scriptLoader.LoadScriptsFromOptions(); } } if (result != null) { _logger.StopScriptLoading(result.Count); } return(result); }
/// <summary> /// Runs the run action. /// </summary> /// <returns></returns> public override int Run() { int result = 0; SanitizedConfiguration config = LoadConfiguration(); if (IsKerboscript(_options.Script) == true) { string fullScriptPath = Path.GetFullPath(_options.Script); _logger.StartKerboscriptExecution(fullScriptPath); result = ExecuteKerboscript(fullScriptPath, config); if (result == 0) { _logger.StopKerboscriptExecution(fullScriptPath); } } else { if (config != null) { Models.Script script = config.Scripts.Find(s => s.Name == _options.Script); if (script != null) { result = ExecuteConfigScript(script); } else { _logger.ScriptNotFound(_options.Script); result = 1; } } } return(result); }
/// <summary> /// Removes compiled scripts based on either given options or configuration. /// </summary> /// <param name="config">Loaded project configuration.</param> public void RemoveCompiledScripts(SanitizedConfiguration config) { if (config != null) { foreach (var volume in config.GetVolumesForOption(_options.Volume)) { if (Directory.Exists(volume.OutputPath) == true) { Directory.Delete(volume.OutputPath, true); } } } else { if (_options.Output != Constants.CurrentDirectory) { if (Directory.Exists(_options.Output) == true) { Directory.Delete(_options.Output, true); } else if (File.Exists(_options.Output) == true) { File.Delete(_options.Output); } } } }
/// <summary> /// Reads a configuration from a file from disk. /// </summary> /// <param name="filepath">Filepath to the configuration file.</param> /// <returns>Read configuration.</returns> public static SanitizedConfiguration ReadConfigFile(string filepath) { SanitizedConfiguration result = null; if (File.Exists(filepath) == true) { string configJSON = File.ReadAllText(filepath); result = Configuration.FromJson(configJSON).GetSanitized(); } return(result); }
/// <summary> /// Reads the config file from the current directory. /// </summary> /// <returns>Read configuration.</returns> public static SanitizedConfiguration ReadConfigFileFromCurrentDirectory() { SanitizedConfiguration result = null; string configFilepath = Path.Combine(Directory.GetCurrentDirectory(), Constants.ConfigFileName); if (File.Exists(configFilepath) == true) { result = ConfigIO.ReadConfigFile(configFilepath); } return(result); }
public void InitConfigWithProjectName([Values("foobar", "foo-bar", "foo_bar")] string ProjectName) { // Build up. string arguments = "init " + ProjectName + " -y"; // Test. int result = ActionDispatcher.Dispatch(arguments.Split(' '), false); // General asserts. Assert.AreEqual(0, result); string configFilePath = Path.GetFullPath(Path.Combine("./", Constants.ConfigFileName)); Assert.IsTrue(File.Exists(configFilePath)); // Content asserts. string configContent = File.ReadAllText(configFilePath); Assert.IsNotNull(configContent); // Data model asserts. SanitizedConfiguration config = Configuration.FromJson(configContent).GetSanitized(); Assert.IsNotNull(config); Assert.IsNotNull(config.Name); Assert.AreEqual(ProjectName, config.Name); // Volumes asserts. Assert.IsNotNull(config.Volumes); Assert.AreEqual(2, config.Volumes.Count); Assert.AreEqual(1, config.Volumes[0].Index); Assert.AreEqual(2, config.Volumes[1].Index); Assert.AreEqual("boot", config.Volumes[0].Name); Assert.AreEqual(ProjectName, config.Volumes[1].Name); Assert.AreEqual(Constants.DefaultBootVolumePath, config.Volumes[0].InputPath); Assert.AreEqual(Constants.DefaultVolumePath, config.Volumes[1].InputPath); // Scripts asserts. Assert.IsNotNull(config.Scripts); Assert.AreEqual(2, config.Scripts.Count); Assert.AreEqual("compile", config.Scripts[0].Name); Assert.AreEqual("deploy", config.Scripts[1].Name); // Default files and directory asserts. // Tear down. File.Delete(configFilePath); Directory.Delete(Path.GetFullPath(Constants.DefaultVolumePath), true); Directory.Delete(Path.GetFullPath(Constants.DefaultBootVolumePath), true); Directory.Delete(Path.GetFullPath(Constants.DefaultScriptVolumePath), true); }
/// <summary> /// Asks the user interactively for the config information. /// </summary> /// <returns>Resulting configuration.</returns> private SanitizedConfiguration AskConfig() { PrintWelcomeText(); SanitizedConfiguration result = new SanitizedConfiguration(); // Ask the mandatory information. if (_options.ProjectName == string.Empty) { result.Name = Ask("Project name", GetProjectNameDefault()); } else { result.Name = _options.ProjectName; } result.Description = Ask("Project description"); result.Archive = Ask("Project archive (used KSP installation)", FindKSPInstallation()); if (result.Archive == Constants.DefaultKSPSteamInstallationWin32 || result.Archive == Constants.DefaultKSPSteamInstallationWin64) { result.Archive = result.Archive + Constants.ArchivePath; } // Ask for volumes. Volume volume = new Volume(); volume.Index = 2; volume.Name = Ask("Project volume name (volume with your code)", GetProjectNameDefault()); volume.InputPath = Ask("Project volume source directory", Constants.DefaultVolumePath); volume.OutputPath = Ask("Project volume dist directory", Constants.DistDirectory); volume.DeployPath = Constants.CurrentDirectory; Console.WriteLine("You can add more volumes in the created config file!"); result.Volumes.Add(new Volume { Index = 1, Name = "boot", InputPath = Constants.DefaultBootVolumePath, OutputPath = Constants.DistBootDirectory, DeployPath = "./boot" }); result.Volumes.Add(volume); // Create two default scripts. AddDefaultScripts(result); return(result); }
/// <summary> /// Loads scripts based on a given configuration. /// </summary> /// <param name="config">Configuration to load from.</param> /// <returns>List of loaded Kerboscripts.</returns> public List <Kerboscript> LoadScriptsFromConfig(SanitizedConfiguration config) { List <Kerboscript> result = new List <Kerboscript>(); foreach (var volume in config.GetVolumesForOption(_compilerOptions.Volume)) { List <Kerboscript> scripts = LoadScriptsAndAddVolumes(volume.InputPath, volume.OutputPath, volume.Name); if (scripts != null) { scripts.ForEach(ks => ks.DeployPath = volume.DeployPath.Replace(".", config.Archive)); result.AddRange(scripts); } } return(result); }
/// <summary> /// Runs the deployment action. /// </summary> /// <returns></returns> public override int Run() { int result = 0; if (_compiler.Run() == 0) { SanitizedConfiguration config = LoadConfiguration(); if (config != null) { _logger.StartScriptDeployment(); result = Deploy(_compiler.CompiledScripts, config); _logger.StopScriptDeployment(_compiler.CompiledScripts.Count); } } return(result); }
/// <summary> /// Executes a Kerboscript. /// </summary> /// <param name="filepath">Filepath to the Kerboscript to execute.</param> /// <returns>CLI return code.</returns> private int ExecuteKerboscript(string filepath, SanitizedConfiguration config) { int result = 0; Executer executer = new Executer(_logger, config); List <string> output = executer.ExecuteScript(filepath); if (executer.Error == true) { result = 1; } else { _logger.PrintScriptOutput(output); } return(result); }
/// <summary> /// Creates the default directories "./src". /// </summary> /// <param name="basePath">Base path where to create the default directories.</param> private void CreateDefaultDirectoriesAndFiles(SanitizedConfiguration config, string basePath) { foreach (Volume volume in config.Volumes) { string pathToCreate = Path.Combine(basePath, volume.InputPath); Directory.CreateDirectory(Path.GetFullPath(pathToCreate)); if (volume.InputPath == Constants.DefaultBootVolumePath) { File.WriteAllText(Path.Combine(Path.GetFullPath(pathToCreate), Constants.DefaultBootScriptFilename), Constants.DefaultBootScriptContent); } } string defaultScriptPath = Path.Combine(basePath, Constants.DefaultScriptVolumePath); Directory.CreateDirectory(Path.GetFullPath(defaultScriptPath)); File.WriteAllText(Path.Combine(defaultScriptPath, Constants.DefaultCompileScriptFilename), Constants.DefaultCompileScriptContent); File.WriteAllText(Path.Combine(defaultScriptPath, Constants.DefaultDeployScriptFilename), Constants.DefaultDeployScriptContent); }
/// <summary> /// Returns all paths that need to be watched. /// </summary> /// <returns>List of paths.</returns> private List <string> GetWatchPaths() { List <string> result = new List <string>(); if ((_options.Input == Constants.CurrentDirectory && _options.Output == Constants.CurrentDirectory) && ConfigIO.IsDirectory(_options.Input) == true) { SanitizedConfiguration config = LoadConfiguration(); if (config != null) { if (_options.Volume == Constants.AllVolumes) { result = config.Volumes.Select((v) => v.InputPath).ToList(); } else { Volume volume = null; if (int.TryParse(_options.Volume, out int index) == true) { volume = config.Volumes.Find(v => v.Index == index); } else { volume = config.Volumes.Find(v => v.Name == _options.Volume); } if (volume != null) { result.Add(volume.InputPath); } } } } else { result.Add(_options.Input); } result = result.Select(p => Path.GetFullPath(p)).ToList(); result = result.FindAll(p => File.Exists(p) || Directory.Exists(p)); return(result); }
/// <summary> /// Runs the initializer. /// </summary> /// <returns>Returns the CLI return code.</returns> public override int Run() { int result = -1; // Create the configuration based on given options. SanitizedConfiguration config = _options.Yes == true?CreateDefaultConfig() : AskConfig(); // Write the configuration to disk based on given options. if (_options.ProjectPath != string.Empty && _options.ProjectPath != null) { string path = Path.Combine(_options.ProjectPath, _options.ProjectName); result = ConfigIO.WriteConfigFile(config.ToConfiguration(), Path.Combine(_options.ProjectPath, _options.ProjectName), true); CreateDefaultDirectoriesAndFiles(config, path); } else { result = ConfigIO.WriteConfigFile(config.ToConfiguration(), Constants.CurrentDirectory, true); CreateDefaultDirectoriesAndFiles(config, basePath: Constants.CurrentDirectory); } return(result); }
/// <summary> /// Deploys the scripts based on the options and given configuration. /// </summary> /// <param name="scripts">Scripts to deploy.</param> /// <param name="config">Configuration used for the deployment.</param> /// <returns>CLI return code.</returns> private int Deploy(List <Kerboscript> scripts, SanitizedConfiguration config) { int result = 0; List <Volume> volumes = config.GetVolumesForOption(_options.Volume); foreach (Volume volume in volumes) { string deployDirectory = volume.DeployPath.Replace(Constants.CurrentDirectory, config.Archive); if (deployDirectory != config.Archive && Directory.Exists(deployDirectory)) { Directory.Delete(deployDirectory, true); } else { string[] files = Directory.GetFiles(deployDirectory); foreach (string file in files) { File.Delete(file); } } } foreach (Kerboscript script in scripts) { _logger.DeployingScript(script); string fileName = _options.DeploySource ? Path.GetFileName(script.InputPath) : Path.GetFileName(script.OutputPath); string deployPath = Path.Combine(script.DeployPath, fileName); Directory.CreateDirectory(Path.GetDirectoryName(deployPath)); File.Copy(script.OutputPath, deployPath, true); } return(result); }
/// <summary> /// Adds default scripts to a configuration. /// </summary> /// <param name="config">Configuration to add it to.</param> private void AddDefaultScripts(SanitizedConfiguration config) { config.Scripts.Add(new Script("compile", "ksc run " + Constants.DefaultScriptVolumePath + "/" + Constants.DefaultCompileScriptFilename)); config.Scripts.Add(new Script("deploy", "ksc run compile && ksc run " + Constants.DefaultScriptVolumePath + "/" + Constants.DefaultDeployScriptFilename)); }
public void InitConfigWithProjectNameAndPath( [Values("project-name")] string ProjectName, [Values("./foo/bar", "./foobar", "./foo/bar/test/dasfasdf")] string ProjectPath ) { // Build up. string arguments = "init " + ProjectName + " " + ProjectPath + " -y"; // Test. int result = ActionDispatcher.Dispatch(arguments.Split(' '), false); // General asserts. Assert.AreEqual(0, result); string configFilePath = Path.GetFullPath(Path.Combine(Path.Combine(Path.GetFullPath(ProjectPath), ProjectName), Constants.ConfigFileName)); Assert.IsTrue(File.Exists(configFilePath)); // Content asserts. string configContent = File.ReadAllText(configFilePath); Assert.IsNotNull(configContent); // Data model asserts. SanitizedConfiguration config = Configuration.FromJson(configContent).GetSanitized(); Assert.IsNotNull(config); Assert.IsNotNull(config.Name); Assert.AreEqual(ProjectName, config.Name); // Volumes asserts. Assert.IsNotNull(config.Volumes); Assert.AreEqual(2, config.Volumes.Count); Assert.AreEqual(1, config.Volumes[0].Index); Assert.AreEqual(2, config.Volumes[1].Index); Assert.AreEqual("boot", config.Volumes[0].Name); Assert.AreEqual(ProjectName, config.Volumes[1].Name); Assert.AreEqual(Constants.DefaultBootVolumePath, config.Volumes[0].InputPath); Assert.AreEqual(Constants.DefaultVolumePath, config.Volumes[1].InputPath); // Scripts asserts. Assert.IsNotNull(config.Scripts); Assert.AreEqual(2, config.Scripts.Count); Assert.AreEqual("compile", config.Scripts[0].Name); Assert.AreEqual("deploy", config.Scripts[1].Name); // Default files and directory asserts. // Tear down. File.Delete(configFilePath); DirectoryInfo dirInfo = new DirectoryInfo(Path.GetFullPath(ProjectPath)); int count = ProjectPath.Count(s => s == '/'); if (count > 1) { for (int i = count - 1; i > 0; i--) { dirInfo = Directory.GetParent(dirInfo.FullName); } } Directory.Delete(dirInfo.FullName, true); }