protected override void Process(ExportArgs args)
    {
      var websiteName = args.Instance.Name;
      var appPoolName = new Website(args.Instance.ID).GetPool(new WebServerManager.WebServerContext(string.Empty)).Name;

      var websiteSettingsCommand = string.Format(@"%windir%\system32\inetsrv\appcmd list site {0}{1}{0} /config /xml > {2}", '"', websiteName, Path.Combine(args.Folder, "WebsiteSettings.xml"));
      var appPoolSettingsCommand = string.Format(@"%windir%\system32\inetsrv\appcmd list apppool {0}{1}{0} /config /xml > {2}", '"', appPoolName, Path.Combine(args.Folder, "AppPoolSettings.xml"));

      EcexuteCommand(websiteSettingsCommand);
      EcexuteCommand(appPoolSettingsCommand);
    }
Esempio n. 2
0
        private void BackupFolder([NotNull] ExportArgs args, [NotNull] string path, [NotNull] string fileName)
        {
            Assert.ArgumentNotNull(args, "args");
            Assert.ArgumentNotNull(path, "path");
            Assert.ArgumentNotNull(fileName, "fileName");

            if (!FileSystem.FileSystem.Local.Directory.Exists(path))
            {
                return;
            }

            var backupFolder = Path.Combine(args.Folder, fileName);

            DirectoryCopy(path, backupFolder);
        }
Esempio n. 3
0
        protected override void Process(ExportArgs args)
        {
            var websiteName = args.Instance.Name;

            using (var context = new WebServerManager.WebServerContext())
            {
                var appPoolName = new Website(args.Instance.ID).GetPool(context).Name;

                var websiteSettingsCommand = string.Format(@"%windir%\system32\inetsrv\appcmd list site {0}{1}{0} /config /xml > {2}", '"', websiteName, Path.Combine(args.Folder, "WebsiteSettings.xml"));
                var appPoolSettingsCommand = string.Format(@"%windir%\system32\inetsrv\appcmd list apppool {0}{1}{0} /config /xml > {2}", '"', appPoolName, Path.Combine(args.Folder, "AppPoolSettings.xml"));

                ExecuteCommand(websiteSettingsCommand);
                ExecuteCommand(appPoolSettingsCommand);
            }
        }
        protected override void Process(ExportArgs args)
        {
            var zipName          = args.ExportFile;
            var compressionLevel = Settings.CoreExportZipCompressionLevel.Value;

            CompressionLevel zipCompressionLevel;

            if (compressionLevel < 3 && typeof(CompressionLevel).IsEnumDefined(compressionLevel))
            {
                zipCompressionLevel = (CompressionLevel)compressionLevel;
            }
            else
            {
                zipCompressionLevel = CompressionLevel.Optimal;
            }

            ZipFile.CreateFromDirectory(args.Folder, zipName, zipCompressionLevel, false);
        }
        protected override void Process([NotNull] ExportArgs args)
        {
            Assert.ArgumentNotNull(args, "args");

            var selectedDatabases     = args.SelectedDatabases;
            var attachedDatabases     = args.Instance.AttachedDatabases;
            var exportDatabasesFolder = FileSystem.FileSystem.Local.Directory.Ensure(Path.Combine(args.Folder, "Databases"));

            foreach (var database in attachedDatabases.Where(database => selectedDatabases.Contains(database.Name.ToLower())))
            {
                if (this.done.Contains(database.Name))
                {
                    continue;
                }

                this.Backup(database, exportDatabasesFolder);
                this.done.Add(database.Name);
            }
        }
    protected override void Process(ExportArgs args)
    {
      Assert.ArgumentNotNull(args, "args");

      var mongoDatabases = args.Instance.MongoDatabases;
      var exportDatabasesFolder = FileSystem.FileSystem.Local.Directory.Ensure(Path.Combine(args.Folder, "MongoDatabases"));

      foreach (var database in mongoDatabases)
      {
        if (this.done.Contains(database.Name))
        {
          continue;
        }

        MongoHelper.Backup(database, exportDatabasesFolder);
        this.IncrementProgress();

        this.done.Add(database.Name);
      }
    }
        protected override void Process(ExportArgs args)
        {
            Assert.ArgumentNotNull(args, "args");

            var mongoDatabases        = args.Instance.MongoDatabases;
            var exportDatabasesFolder = FileSystem.FileSystem.Local.Directory.Ensure(Path.Combine(args.Folder, "MongoDatabases"));

            foreach (var database in mongoDatabases)
            {
                if (this.done.Contains(database.Name))
                {
                    continue;
                }

                MongoHelper.Backup(database, exportDatabasesFolder);
                this.IncrementProgress();

                this.done.Add(database.Name);
            }
        }
        protected override bool IsRequireProcessing(ExportArgs args)
        {
            Assert.ArgumentNotNull(args, "args");

            return(args.IncludeMongoDatabases);
        }
        protected override long EvaluateStepsCount([NotNull] ExportArgs args)
        {
            Assert.ArgumentNotNull(args, nameof(args));

            return(args.Instance.MongoDatabases.Count());
        }
 protected override void Process(ExportArgs args)
 {
   var zipName = args.ExportFile;
   FileSystem.FileSystem.Local.Zip.CreateZip(args.Folder, zipName, compressionLevel: Settings.CoreExportZipCompressionLevel.Value);
 }
Esempio n. 11
0
        protected override void Process([NotNull] ExportArgs args)
        {
            Assert.ArgumentNotNull(args, nameof(args));

            var instance      = args.Instance;
            var webRootPath   = instance.WebRootPath;
            var webRootName   = instance.WebRootPath.Split('\\')[instance.WebRootPath.Split('\\').Length - 1];
            var websiteFolder = Path.Combine(args.Folder, webRootName);
            var dataFolder    = Path.Combine(args.Folder, "data");


            BackupFolder(args, webRootPath, webRootName);

            // 0
            IncrementProgress();

            BackupFolder(args, instance.DataFolderPath, "Data");

            // 1
            IncrementProgress();

            if (args.WipeSqlServerCredentials)
            {
                WipeSqlServerCredentials(websiteFolder);
            }

            // 2
            IncrementProgress();

            if (!args.IncludeTempFolderContents)
            {
                WipeTempFolderContents(websiteFolder);
            }

            // 3
            IncrementProgress();

            if (!args.IncludeMediaCacheFolderContents)
            {
                WipeMediaCacheFolderContents(websiteFolder);
            }

            // 4
            IncrementProgress();

            if (args.ExcludeUploadFolderContents)
            {
                WipeUploadFolderContents(websiteFolder);
            }

            // 5
            IncrementProgress();

            if (true)
            {
                WipeViewStateFolderContents(dataFolder);
            }

            // 6
            IncrementProgress();

            if (args.ExcludeDiagnosticsFolderContents)
            {
                WipDiagnosticsFolderContents(dataFolder);
            }

            // 7
            IncrementProgress();

            if (args.ExcludeLogsFolderContents)
            {
                WipeLogsFolderContents(dataFolder);
            }

            // 8
            IncrementProgress();

            if (args.ExcludePackagesFolderContents)
            {
                WipePackagesFolderContents(dataFolder);
            }

            // 9
            IncrementProgress();

            if (args.ExcludeLicenseFile)
            {
                WipeLicenseFile(dataFolder);
            }
        }
        protected override void Process(ExportArgs args)
        {
            var zipName = args.ExportFile;

            FileSystem.FileSystem.Local.Zip.CreateZip(args.Folder, zipName, compressionLevel: Settings.CoreExportZipCompressionLevel.Value);
        }
Esempio n. 13
0
        protected virtual bool IsRequireProcessing([NotNull] ExportArgs args)
        {
            Assert.ArgumentNotNull(args, nameof(args));

            return(true);
        }
 protected virtual long EvaluateStepsCount(ExportArgs args)
 {
     return 1;
 }
    protected override bool IsRequireProcessing(ExportArgs args)
    {
      Assert.ArgumentNotNull(args, "args");

      return args.IncludeMongoDatabases;
    }
        protected override long EvaluateStepsCount(ExportArgs args)
        {
            Assert.ArgumentNotNull(args, "args");

              return 1 + 10;
        }
        protected override long EvaluateStepsCount(ExportArgs args)
        {
            Assert.ArgumentNotNull(args, "args");

            return(args.Instance.AttachedDatabases.Count());
        }
 protected override void Process(ExportArgs args)
 {
     var exportFile = args.ExportFile;
     CreateZip(args.Folder, exportFile);
     Directory.Delete(args.Folder, true);
 }
Esempio n. 19
0
 protected virtual long EvaluateStepsCount(ExportArgs args)
 {
     return(1);
 }
    protected override long EvaluateStepsCount(ExportArgs args)
    {
      Assert.ArgumentNotNull(args, "args");

      return args.Instance.AttachedDatabases.Count();
    }
Esempio n. 21
0
 protected abstract void Process([NotNull] ExportArgs args);
Esempio n. 22
0
        protected override long EvaluateStepsCount(ExportArgs args)
        {
            Assert.ArgumentNotNull(args, nameof(args));

            return(1 + 10);
        }