Ejemplo n.º 1
0
        /// <summary>
        /// Returns a default instance of <see cref="ApplicationData"/> for the packaging of <see cref="executable"/>.
        /// </summary>
        /// <exception cref="ArgumentNullException"></exception>
        /// <exception cref="ArgumentException">
        /// An <see cref="ArgumentException"/> is thrown if the value specified for <paramref name="executable"/> is invalid.
        /// </exception>
        /// <param name="executable"></param>
        /// <returns></returns>
        public static ApplicationData GetDefaultApplicationData(string executable)
        {
            if (string.IsNullOrEmpty(executable))
            {
                throw new ArgumentNullException("executable");
            }
            ApplicationData data = new ApplicationData();

            data.Settings.RegistryEngineRuleCollection = RegistryRuleCollection.GetDefaultRuleCollection();
            data.Files.RootDirectory = new ApplicationFile(".");
            data.Files.Executable    = new ApplicationFile(executable);
            if (data.Files.Executable.Type != FileType.Executable)
            {
                throw new ArgumentException("The value specified for the executable is invalid.", "executable");
            }
            data.Files.RegistryDatabase = new ApplicationFile(_dbRegistry);
            return(data);
        }
Ejemplo n.º 2
0
 public void BindDataSource(ApplicationData dataSource)
 {
     if (dataSource == null)
     {
         throw new ArgumentNullException("dataSource");
     }
     _data = dataSource;
     if (_data.Settings.FileSystemEngineRuleCollection == null)
     {
         _data.Settings.FileSystemEngineRuleCollection = FileSystemRuleCollection.GetDefaultRuleCollection();
     }
     if (_data.Settings.RegistryEngineRuleCollection == null)
     {
         _data.Settings.RegistryEngineRuleCollection = RegistryRuleCollection.GetDefaultRuleCollection();
     }
     _fileSystemEngineSettingsPageContent.BindRuleCollection(_data.Settings.FileSystemEngineRuleCollection, FileSystemRuleCollectionUpdateEventHandler);
     _registryEngineSettingsPageContent.BindRuleCollection(_data.Settings.RegistryEngineRuleCollection, RegistryRuleCollectionUpdateEventHandler);
     Enabled = true;
 }
Ejemplo n.º 3
0
 /// <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();
 }
Ejemplo n.º 4
0
 /// <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;
 }
 protected override EngineRuleCollection GetEmptyRuleCollection()
 {
     return(RegistryRuleCollection.GetEmptyRuleCollection());
 }
Ejemplo n.º 6
0
 /// <summary>
 /// Initializes a new instance of <see cref="RegistrySwitch"/>.
 /// </summary>
 /// <param name="indexGenerator">The <see cref="IndexGenerator"/> to use for generating virtual key handles.</param>
 /// <param name="knownKeys">A list of all known virtual registry keys.</param>
 /// <param name="ruleCollection">The collection of engine rules to consider when deciding on a target registry.</param>
 public RegistrySwitch(IndexGenerator indexGenerator, IDictionary <uint, VirtualRegistryKey> knownKeys, RegistryRuleCollection ruleCollection)
 {
     _transparentRegistry = new TransparentRegistry(indexGenerator);
     _virtualRegistry     = new VirtualRegistry(indexGenerator, knownKeys);
     _engineRules         = ruleCollection;
 }