/// <summary>
 /// Initializes a new instance of <see cref="FileSystemProvider"/>,
 /// using the <paramref name="rootDirectory"/> specified as root.
 /// </summary>
 /// <param name="rootDirectory">
 /// The path to use as root directory.
 /// All filenames going in and out of the current <see cref="FileSystemProvider"/> should be interpreted as relatives to this path.
 /// </param>
 /// <param name="engineRules">
 /// The collection of engine rules to apply during the virtualization process.
 /// </param>
 public FileSystemProvider(string rootDirectory, FileSystemRuleCollection engineRules)
 {
   if (rootDirectory == null)
     throw new ArgumentNullException("rootDirectory");
   _engineRules = engineRules;
   _virtualEnvironment = new VirtualEnvironment(rootDirectory);
 }
Example #2
0
        /// <summary>
        /// Returns the default collection of file system rules.
        /// </summary>
        /// <returns></returns>
        public static FileSystemRuleCollection GetDefaultRuleCollection()
        {
            var rules = new FileSystemRuleCollection();

            rules.PopulateWithDefaultRules();
            return(rules);
        }
 /// <summary>
 /// Initializes a new instance of <see cref="ProcessSynchronizer"/>.
 /// The constructor will create default databases from the specified files.
 /// </summary>
 /// <param name="fileSystemRoot">The directory to use as root of the file system.</param>
 /// <param name="fileSystemRuleCollection">The collection of engine rules to apply on the file system virtualization engine.</param>
 /// <param name="registryDatabaseFile">The file to use with a default <see cref="RegistryDatabase"/>.</param>
 /// <param name="registryRuleCollection">The collection of engine rules to apply on the registry virtualization engine.</param>
 public ProcessSynchronizer(ApplicationFile fileSystemRoot, FileSystemRuleCollection fileSystemRuleCollection,
   ApplicationFile registryDatabaseFile, RegistryRuleCollection registryRuleCollection)
 {
   if (fileSystemRoot.Type != FileType.Directory)
     throw new ArgumentException("The root location specified for the file system is not valid.", "fileSystemRoot");
   if (registryDatabaseFile.Type != FileType.Database)
     throw new ArgumentException("The filename specified for the registry database is not valid.", "registryDatabaseFile");
   _connectionStrings = new Dictionary<ConfigurationDataType, string>(2)
                          {
                            {ConfigurationDataType.RegistryDatabaseFile, registryDatabaseFile.FileName},
                            {ConfigurationDataType.FileSystemRoot, fileSystemRoot.FileName}
                          };
   _fsRuleCollection = fileSystemRuleCollection;
   _regRuleCollection = registryRuleCollection;
 }
 /// <summary>
 /// Returns the default collection of file system rules.
 /// </summary>
 /// <returns></returns>
 public static FileSystemRuleCollection GetDefaultRuleCollection()
 {
   var rules = new FileSystemRuleCollection();
   rules.PopulateWithDefaultRules();
   return rules;
 }
 /// <summary>
 /// Initializes a new instance of <see cref="VirtualProcessStartInfo"/>
 ///  based on the <see cref="ApplicationData"/> specified.
 /// </summary>
 /// <exception cref="ArgumentNullException">
 /// An <see cref="ArgumentNullException"/> is thrown if <paramref name="data"/> of one of its properties is null.
 /// </exception>
 /// <exception cref="ArgumentException">
 /// An <see cref="ArgumentException"/> is thrown if any of the properties of <paramref name="data"/> is of the wrong type.
 /// </exception>
 /// <param name="data">The data to base the process on.</param>
 /// <param name="workingDirectory">The working directory of the process to start.</param>
 public VirtualProcessStartInfo(ApplicationData data, ApplicationFile workingDirectory)
 {
   if (data == null
       || data.Files.RegistryDatabase == null
       || data.Files.Executable == null
       || data.Files.RootDirectory == null)
     throw new ArgumentNullException("data", "The data argument or one of its properties is null.");
   if (workingDirectory == null)
     throw new ArgumentNullException("workingDirectory", "The workingDirectory argument is null.");
   if (data.Files.Executable.Type != FileType.Executable)
     throw new ArgumentException("The ApplicationData specified contains an illegal value for the main executable.",
                                 "data");
   if (data.Files.RegistryDatabase.Type != FileType.Database)
     throw new ArgumentException(
       "The ApplicationData specified contains an illegal value for the registry database.",
       "data");
   if (workingDirectory.Type != FileType.Directory)
     throw new ArgumentException("The working directory specified is not a directory.",
                                 "workingDirectory");
   _files = new ApplicationFiles
              {
                RegistryDatabase
                  = new ApplicationFile(Path.Combine(workingDirectory.FileName, data.Files.RegistryDatabase.FileName)),
                Executable
                  = new ApplicationFile(Path.Combine(workingDirectory.FileName, data.Files.Executable.FileName)),
                RootDirectory
                  = new ApplicationFile(Path.Combine(workingDirectory.FileName, data.Files.RootDirectory.FileName))
              };
   _arguments = "";
   _workingDirectory = workingDirectory;
   _fileSystemRuleCollection = data.Settings.FileSystemEngineRuleCollection ?? FileSystemRuleCollection.GetDefaultRuleCollection();
   _registryRuleCollection = data.Settings.RegistryEngineRuleCollection ?? RegistryRuleCollection.GetDefaultRuleCollection();
 }