Example #1
0
 /// <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);
             }
         }
     }
 }
Example #2
0
        /// <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);
        }
Example #3
0
        /// <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);
        }