示例#1
0
        /// <summary>
        /// Creates example notepad daemon.
        /// </summary>
        /// <returns>File watcher configuration set.</returns>
        private static FileWatcherConfigurationSet GetNotepadDaemonConfiguration()
        {
            FileWatcherConfigurationSet fileWatcherConfigurationSet =
                new FileWatcherConfigurationSet();

            fileWatcherConfigurationSet.StartDaemon             = true;
            fileWatcherConfigurationSet.DisplayFileSystemChange = true;
            fileWatcherConfigurationSet.LogFileSystemChange     = true;
            fileWatcherConfigurationSet.Path   = Environment.CurrentDirectory;
            fileWatcherConfigurationSet.Filter = "*.txt";
            fileWatcherConfigurationSet.IncludeSubdirectories       = false;
            fileWatcherConfigurationSet.InternalBufferSize          = 8192;
            fileWatcherConfigurationSet.SubscribeToBufferErrorEvent = true;
            fileWatcherConfigurationSet.SubscribeToChangedEvent     = true;
            fileWatcherConfigurationSet.SubscribeToCreatedEvent     = true;
            fileWatcherConfigurationSet.SubscribeToDeletedEvent     = true;
            fileWatcherConfigurationSet.SubscribeToRenamedEvent     = true;
            fileWatcherConfigurationSet.NotifyFilterAttributes      = false;
            fileWatcherConfigurationSet.NotifyFilterCreationTime    = false;
            fileWatcherConfigurationSet.NotifyFilterDirectoryName   = true;
            fileWatcherConfigurationSet.NotifyFilterFileName        = true;
            fileWatcherConfigurationSet.NotifyFilterLastAccess      = false;
            fileWatcherConfigurationSet.NotifyFilterLastWrite       = true;
            fileWatcherConfigurationSet.NotifyFilterSecurity        = false;
            fileWatcherConfigurationSet.NotifyFilterSize            = false;

            fileWatcherConfigurationSet.StartProcess     = true;
            fileWatcherConfigurationSet.LogProcessStart  = true;
            fileWatcherConfigurationSet.LogProcessEnd    = true;
            fileWatcherConfigurationSet.ProcessFileName  = "notepad.exe";
            fileWatcherConfigurationSet.ProcessArguments = "[processArgumentsFileName]";
            fileWatcherConfigurationSet.ProcessUseChangeTypeAsArgument          = false;
            fileWatcherConfigurationSet.ProcessArgumentsChangeTypeEscapeString  = "";
            fileWatcherConfigurationSet.ProcessUseFileNameAsArgument            = true;
            fileWatcherConfigurationSet.ProcessArgumentsFileNameEscapeString    = "[processArgumentsFileName]";
            fileWatcherConfigurationSet.ProcessUseOldFileNameAsArgument         = false;
            fileWatcherConfigurationSet.ProcessArgumentsOldFileNameEscapeString = "";
            fileWatcherConfigurationSet.ProcessVerb                   = "";
            fileWatcherConfigurationSet.ProcessWorkingDirectory       = Environment.CurrentDirectory;
            fileWatcherConfigurationSet.ProcessUseShellExecute        = false;
            fileWatcherConfigurationSet.ProcessCreateNoWindow         = false;
            fileWatcherConfigurationSet.ProcessWindowStyle            = "Normal";
            fileWatcherConfigurationSet.ProcessSynchronizedExecution  = false;
            fileWatcherConfigurationSet.ProcessMaxWaitTime            = 0;
            fileWatcherConfigurationSet.ProcessRedirectStandardError  = false;
            fileWatcherConfigurationSet.ProcessRedirectStandardOutput = false;
            fileWatcherConfigurationSet.ProcessLoadUserProfile        = false;
            fileWatcherConfigurationSet.ProcessDomain                 = "";
            fileWatcherConfigurationSet.ProcessUserName               = "";
            fileWatcherConfigurationSet.ProcessPassword               = "";

            return(fileWatcherConfigurationSet);
        }
        /// <summary>
        /// Loads configuration from XML files.
        /// </summary>
        /// <param name="xmlConfigFilePath">Path of the configuration XML file.</param>
        /// <param name="xmlSchemaConfigFilePath">Path of the configuration XML Schema file.</param>
        /// <returns>Configuration dictionary.</returns>
        /// <exception cref="ArgumentNullException">Dictionary key (daemonName) is null.</exception>
        /// <exception cref="ArgumentException">Duplicate key (daemonName) in configuration.</exception>
        /// <remarks>Throws all exceptions defined in FileWatcherConfigurationSet.</remarks>
        private static Dictionary <string, FileWatcherConfigurationSet> LoadConfigurationToDictionary(string xmlConfigFilePath,
                                                                                                      string xmlSchemaConfigFilePath)
        {
            Dictionary <string, FileWatcherConfigurationSet> configurationDictionary =
                new Dictionary <string, FileWatcherConfigurationSet>();

            using (DataSet dataSet = new DataSet())
            {
                dataSet.Locale = CultureInfo.InvariantCulture;

                dataSet.ReadXmlSchema(xmlSchemaConfigFilePath);
                dataSet.ReadXml(xmlConfigFilePath);

                // Load configuration sets to dictionary.
                foreach (DataRow dataRow in dataSet.Tables[Resources.TableName].Rows)
                {
                    FileWatcherConfigurationSet fileWatcherConfigSet =
                        new FileWatcherConfigurationSet();

                    fileWatcherConfigSet.StartDaemon =
                        (bool)dataRow[Resources.ColumnStartDaemon];

                    fileWatcherConfigSet.DisplayFileSystemChange =
                        (bool)dataRow[Resources.ColumnDisplayFileSystemChange];

                    fileWatcherConfigSet.LogFileSystemChange =
                        (bool)dataRow[Resources.ColumnLogFileSystemChange];

                    fileWatcherConfigSet.LogFileSystemSearchError =
                        (bool)dataRow[Resources.ColumnLogFileSystemSearchError];

                    fileWatcherConfigSet.DisplayFileSystemSearchError =
                        (bool)dataRow[Resources.ColumnDisplayFileSystemSearchError];

                    fileWatcherConfigSet.LogFileSystemSearchProgress =
                        (bool)dataRow[Resources.ColumnLogFileSystemSearchProgress];

                    fileWatcherConfigSet.DisplayFileSystemSearchProgress =
                        (bool)dataRow[Resources.ColumnDisplayFileSystemSearchProgess];

                    fileWatcherConfigSet.Path =
                        (string)dataRow[Resources.ColumnPath];

                    fileWatcherConfigSet.Filter =
                        (string)dataRow[Resources.ColumnFilter];

                    fileWatcherConfigSet.GenerateFileSystemEventsAtStartup =
                        (bool)dataRow[Resources.ColumnGenerateFileSystemEventsAtStartup];

                    fileWatcherConfigSet.GeneratedEventFileNameRegularExpressionFilter =
                        (string)dataRow[Resources.ColumnGenereatedEventFileNameRegularExpressionFilter];

                    fileWatcherConfigSet.ChangedRegularExpressionFilter =
                        (string)dataRow[Resources.ColumnChangedRegularExpressionFilter];

                    fileWatcherConfigSet.CreatedRegularExpressionFilter =
                        (string)dataRow[Resources.ColumnCreatedRegularExpressionFilter];

                    fileWatcherConfigSet.DeletedRegularExpressionFilter =
                        (string)dataRow[Resources.ColumnDeletedRegularExpressionFilter];

                    fileWatcherConfigSet.RenamedRegularExpressionFilter =
                        (string)dataRow[Resources.ColumnRenamedRegularExpressionFilter];

                    fileWatcherConfigSet.IncludeSubdirectories =
                        (bool)dataRow[Resources.ColumnIncludeSubdirectories];

                    fileWatcherConfigSet.InternalBufferSize =
                        (int)dataRow[Resources.ColumnInternalBufferSize];

                    fileWatcherConfigSet.SubscribeToBufferErrorEvent =
                        (bool)dataRow[Resources.ColumnSubscribeToBufferErrorEvent];

                    fileWatcherConfigSet.SubscribeToChangedEvent =
                        (bool)dataRow[Resources.ColumnSubscribeToChangedEvent];

                    fileWatcherConfigSet.SubscribeToCreatedEvent =
                        (bool)dataRow[Resources.ColumnSubscribeToCreatedEvent];

                    fileWatcherConfigSet.SubscribeToDeletedEvent =
                        (bool)dataRow[Resources.ColumnSubscribeToDeletedEvent];

                    fileWatcherConfigSet.SubscribeToRenamedEvent =
                        (bool)dataRow[Resources.ColumnSubscribeToRenamedEvent];

                    fileWatcherConfigSet.NotifyFilterAttributes =
                        (bool)dataRow[Resources.ColumnNotifyAttribute];

                    fileWatcherConfigSet.NotifyFilterCreationTime =
                        (bool)dataRow[Resources.ColumnNotifyCreationTime];

                    fileWatcherConfigSet.NotifyFilterDirectoryName =
                        (bool)dataRow[Resources.ColumnNotifyDirectoryName];

                    fileWatcherConfigSet.NotifyFilterFileName =
                        (bool)dataRow[Resources.ColumnNotifyFileName];

                    fileWatcherConfigSet.NotifyFilterLastAccess =
                        (bool)dataRow[Resources.ColumnNotifyLastAccess];

                    fileWatcherConfigSet.NotifyFilterLastWrite =
                        (bool)dataRow[Resources.ColumnNotifyLastWrite];

                    fileWatcherConfigSet.NotifyFilterSecurity =
                        (bool)dataRow[Resources.ColumnNotifySecurity];

                    fileWatcherConfigSet.NotifyFilterSize =
                        (bool)dataRow[Resources.ColumnNotifySize];

                    fileWatcherConfigSet.StartProcess =
                        (bool)dataRow[Resources.ColumnStartProcess];

                    fileWatcherConfigSet.LogProcessStart =
                        (bool)dataRow[Resources.ColumnLogProcessStart];

                    fileWatcherConfigSet.LogProcessEnd =
                        (bool)dataRow[Resources.ColumnLogProcessEnd];

                    fileWatcherConfigSet.ProcessFileName =
                        (string)dataRow[Resources.ColumnProcessFileName];

                    fileWatcherConfigSet.ProcessArguments =
                        (string)dataRow[Resources.ColumnProcessArguments];

                    fileWatcherConfigSet.ProcessUseFileNameAsArgument =
                        (bool)dataRow[Resources.ColumnProcessUseFileNameAsArgument];

                    fileWatcherConfigSet.ProcessArgumentsFileNameEscapeString =
                        (string)dataRow[Resources.ColumnProcessArgumentsFileNameEscapeString];

                    fileWatcherConfigSet.ProcessUseOldFileNameAsArgument =
                        (bool)dataRow[Resources.ColumnProcessUseOldFileNameAsArgument];

                    fileWatcherConfigSet.ProcessArgumentsOldFileNameEscapeString =
                        (string)dataRow[Resources.ColumnProcessArgumentsOldFileNameEscapeString];

                    fileWatcherConfigSet.ProcessUseChangeTypeAsArgument =
                        (bool)dataRow[Resources.ColumnProcessUseChangeTypeAsArgument];

                    fileWatcherConfigSet.ProcessArgumentsChangeTypeEscapeString =
                        (string)dataRow[Resources.ColumnProcessArgumentsChangeTypeEscapeString];

                    fileWatcherConfigSet.ProcessVerb =
                        (string)dataRow[Resources.ColumnProcessVerb];

                    fileWatcherConfigSet.ProcessWorkingDirectory =
                        (string)dataRow[Resources.ColumnProcessWorkingDirectory];

                    fileWatcherConfigSet.ProcessUseShellExecute =
                        (bool)dataRow[Resources.ColumnProcessUseShellExecute];

                    fileWatcherConfigSet.ProcessCreateNoWindow =
                        (bool)dataRow[Resources.ColumnProcessCreateNoWindow];

                    fileWatcherConfigSet.ProcessWindowStyle =
                        (string)dataRow[Resources.ColumnProcessWindowStyle];

                    fileWatcherConfigSet.ProcessSynchronizedExecution =
                        (bool)dataRow[Resources.ColumnProcessSynchronizedExecution];

                    fileWatcherConfigSet.ProcessMaxWaitTime =
                        (int)dataRow[Resources.ColumnProcessMaxWaitTime];

                    fileWatcherConfigSet.ProcessRedirectStandardError =
                        (bool)dataRow[Resources.ColumnProcessRedirectStandardError];

                    fileWatcherConfigSet.ProcessRedirectStandardOutput =
                        (bool)dataRow[Resources.ColumnProcessRedirectStandardOutput];

                    fileWatcherConfigSet.ProcessLoadUserProfile =
                        (bool)dataRow[Resources.ColumnProcessLoadUserProfile];

                    fileWatcherConfigSet.ProcessDomain =
                        (string)dataRow[Resources.ColumnProcessDomain];

                    fileWatcherConfigSet.ProcessUserName =
                        (string)dataRow[Resources.ColumnProcessUserName];

                    fileWatcherConfigSet.ProcessPassword =
                        (string)dataRow[Resources.ColumnProcessPassword];

                    fileWatcherConfigSet.ProcessBatchSize =
                        (int)dataRow[Resources.ColumnProcessBatchSize];

                    fileWatcherConfigSet.ProcessFileMustExist =
                        (bool)dataRow[Resources.ColumnProcessFileMustExist];

                    fileWatcherConfigSet.ProcessDelay =
                        (int)dataRow[Resources.ColumnProcessDelay];

                    fileWatcherConfigSet.ProcessLockFile =
                        (bool)dataRow[Resources.ColumnProcessLockFile];

                    fileWatcherConfigSet.ProcessLockFileLastWriteDelay =
                        (int)dataRow[Resources.ColumnProcessLockFileLastWriteDelay];

                    fileWatcherConfigSet.ProcessLockFileRetries =
                        (int)dataRow[Resources.ColumnProcessLockFileRetries];

                    fileWatcherConfigSet.ProcessLockFileRetriesQueueLimit =
                        (int)dataRow[Resources.ColumnProcessLockFileRetriesQueueLimit];

                    fileWatcherConfigSet.CallService =
                        (bool)dataRow[Resources.ColumnCallService];

                    fileWatcherConfigSet.StreamFile =
                        (bool)dataRow[Resources.ColumnStreamFile];

                    fileWatcherConfigSet.TryRenameFile =
                        (bool)dataRow[Resources.ColumnTryRenameFile];

                    fileWatcherConfigSet.TryRenameFileRetries =
                        (int)dataRow[Resources.ColumnTryRenameFileRetries];

                    fileWatcherConfigSet.FilteredMode =
                        (bool)dataRow[Resources.ColumnFilteredMode];

                    fileWatcherConfigSet.FilteredModeFilterTimeout =
                        (int)dataRow[Resources.ColumnFilteredModeFilterTimeout];

                    fileWatcherConfigSet.PollDirectory =
                        (bool)dataRow[Resources.ColumnPollDirectory];

                    fileWatcherConfigSet.DirectoryPollInterval =
                        (int)dataRow[Resources.ColumnDirectoryPollInterval];

                    fileWatcherConfigSet.RecycleFileWatcher =
                        (bool)dataRow[Resources.ColumnRecycleFileWatcher];

                    fileWatcherConfigSet.RecycleInterval =
                        (int)dataRow[Resources.ColumnRecycleInterval];

                    try // Catch dictionary related exceptions.
                    {
                        configurationDictionary.Add((string)dataRow[Resources.ColumnDaemonName],
                                                    fileWatcherConfigSet);
                    }
                    catch (ArgumentNullException exception)
                    {
                        throw new ArgumentNullException(Resources.ArgumentExceptionDaemonNameIsNull,
                                                        exception);
                    }
                    catch (ArgumentException exception)
                    {
                        throw new ArgumentException(Resources.ArgumentExceptionDuplicateDaemonName,
                                                    exception);
                    }
                }
            }

            return(configurationDictionary);
        }