コード例 #1
0
        /// <summary>
        /// Initializes the specified config item.
        /// </summary>
        /// <param name="configItem">The config item.</param>
        /// <exception cref="Forge.Configuration.Shared.InvalidConfigurationValueException">CertificateSource value is invalid.
        /// or
        /// CertificateSource value is invalid.
        /// or
        /// CertificateFile value is invalid.
        /// or
        /// Password value is invalid.
        /// or
        /// Subject value is invalid.
        /// or
        /// CertificateSource value is invalid.</exception>
        /// <exception cref="Forge.Configuration.Shared.InvalidConfigurationException">Invalid certificate.
        /// or
        /// Failed to find certificate.
        /// or
        /// Failed to find certificate.</exception>
        public override void Initialize(CategoryPropertyItem configItem)
        {
            if (configItem == null)
            {
                ThrowHelper.ThrowArgumentNullException("configItem");
            }
            if (!IsInitialized)
            {
                CertificateConfigurationSource certSource = new CertificateConfigurationSource();
                certSource.Initialize(configItem);
                mCertificate = certSource.Certificate;

                CategoryPropertyItem pi = ConfigurationAccessHelper.GetCategoryPropertyByPath(configItem.PropertyItems, "Protocol");
                if (pi != null)
                {
                    try
                    {
                        Protocol = (SslProtocols)Enum.Parse(typeof(SslProtocols), pi.EntryValue, true);
                    }
                    catch (Exception)
                    {
                    }
                }

                base.Initialize(configItem);

                IsInitialized = true;
            }
        }
コード例 #2
0
ファイル: StreamFactoryBase.cs プロジェクト: ewin66/Forge
        /// <summary>
        /// Initializes the specified config item.
        /// </summary>
        /// <param name="configItem">The config item.</param>
        public virtual void Initialize(CategoryPropertyItem configItem)
        {
            if (configItem == null)
            {
                ThrowHelper.ThrowArgumentNullException("configItem");
            }

            int value = 8192;

            if (ParseIntValue(configItem, "ReceiveBufferSize", 1024, 65536, ref value))
            {
                this.mReceiveBufferSize = value;
            }

            value = 8192;
            if (ParseIntValue(configItem, "SendBufferSize", 1024, 65536, ref value))
            {
                this.mSendBufferSize = value;
            }

            value = Timeout.Infinite;
            if (ParseIntValue(configItem, "ReceiveTimeout", Timeout.Infinite, int.MaxValue, ref value))
            {
                this.mReceiveTimeout = value;
            }

            value = Timeout.Infinite;
            if (ParseIntValue(configItem, "SendTimeout", Timeout.Infinite, int.MaxValue, ref value))
            {
                this.mSendTimeout = value;
            }

            NoDelay = ParseBooleanValue(configItem, "NoDelay");
        }
コード例 #3
0
ファイル: StorageProviderBase.cs プロジェクト: ewin66/Forge
 /// <summary>
 /// Initializes a new instance of the <see cref="StorageProviderBase&lt;T&gt;"/> class.
 /// </summary>
 /// <param name="storageId">The storage id.</param>
 /// <param name="configItem">The config item.</param>
 protected StorageProviderBase(String storageId, CategoryPropertyItem configItem)
     : this(storageId)
 {
     String formatter          = String.Empty;
     CategoryPropertyItem item = configItem.PropertyItems == null ? null : configItem.PropertyItems["DataFormatter"];
     if (item != null)
     {
         formatter = item.EntryValue;
     }
     if (!String.IsNullOrEmpty(formatter))
     {
         Type type = null;
         try
         {
             type = TypeHelper.GetTypeFromString(formatter);
         }
         catch (Exception ex)
         {
             throw new Exception(String.Format("Unable to resolve data formatter type: {0}", formatter), ex);
         }
         try
         {
             mDataFormatter = (IDataFormatter <T>)type.Assembly.CreateInstance(type.AssemblyQualifiedName);
         }
         catch (Exception ex)
         {
             throw new Exception(String.Format("Unable to instantiate formatter: {0}", formatter), ex);
         }
     }
     else
     {
         mDataFormatter = new BinarySerializerFormatter <T>(BinarySerializerBehaviorEnum.DoNotThrowExceptionOnMissingField, TypeLookupModeEnum.AllowAll, true);
     }
 }
コード例 #4
0
ファイル: StreamFactoryBase.cs プロジェクト: ewin66/Forge
        /// <summary>
        /// Parses the int value.
        /// </summary>
        /// <param name="root">The root.</param>
        /// <param name="entryId">The entry id.</param>
        /// <param name="minValue">The min value.</param>
        /// <param name="maxValue">The max value.</param>
        /// <param name="value">The value.</param>
        /// <returns>True, if the parse method was succeeded, otherwise False.</returns>
        protected static bool ParseIntValue(CategoryPropertyItem root, String entryId, int minValue, int maxValue, ref int value)
        {
            bool result             = false;
            CategoryPropertyItem pi = ConfigurationAccessHelper.GetCategoryPropertyByPath(root.PropertyItems, entryId);

            if (pi != null)
            {
                try
                {
                    value  = int.Parse(pi.EntryValue);
                    result = true;
                }
                catch (FormatException ex)
                {
                    throw new InvalidConfigurationException(String.Format("Invalid value for item: {0}", entryId), ex);
                }
                if (value < minValue)
                {
                    throw new InvalidConfigurationException(String.Format("Minimum value ({0}) is out of range ({1}) for item: {2}", minValue, result, entryId));
                }
                if (value > maxValue)
                {
                    throw new InvalidConfigurationException(String.Format("Maximum value ({0}) is out of range ({1}) for item: {2}", maxValue, result, entryId));
                }
            }
            return(result);
        }
コード例 #5
0
        private void Initialize()
        {
            string appId       = ApplicationHelper.ApplicationId;
            bool   mutexResult = false;
            string typeName    = String.Format("HibernateStorageProvider_{0}_{1}_{2}", appId, StorageId, typeof(T).AssemblyQualifiedName.GetHashCode().ToString());

            if (typeName.Length > 255)
            {
                // limit the length of the mutex name to avoid exception
                typeName = typeName.Substring(0, 255);
            }
            mAppIdMutex = new Mutex(true, typeName, out mutexResult);
            if (!mutexResult)
            {
                throw new InitializationException("An other application with the specified application identifier is running.");
            }

            this.mDeviceId = HashGeneratorHelper.GetSHA256BasedValue(StorageId);
            CategoryPropertyItem pi = ConfigurationAccessHelper.GetCategoryPropertyByPath(StorageConfiguration.Settings.CategoryPropertyItems, String.Format("NHibernateProvider/KnownStorageIdsToReset/{0}", StorageId));

            if (pi != null)
            {
                Reset();
            }
            LoadAllocationTable();
        }
コード例 #6
0
        /// <summary>
        /// Initializes the specified item.
        /// </summary>
        /// <param name="item">The item.</param>
        public override void Initialize(CategoryPropertyItem item)
        {
            base.Initialize(item);

            this.MemberName = null;
            this.Value      = null;
            if (item.PropertyItems != null)
            {
                string memberName = string.Empty;
                if (ConfigurationAccessHelper.ParseStringValue(item.PropertyItems, CONFIG_MEMBERNAME, ref memberName))
                {
                    this.MemberName = memberName;
                }

                string value = string.Empty;
                if (ConfigurationAccessHelper.ParseStringValue(item.PropertyItems, CONFIG_VALUE, ref value))
                {
                    this.Value = value;
                }
            }

            if (string.IsNullOrEmpty(this.MemberName))
            {
                throw new InitializationException("Member name has not been definied.");
            }
        }
コード例 #7
0
 /// <summary>
 /// Initializes the specified item.
 /// </summary>
 /// <param name="item">The item.</param>
 public virtual void Initialize(CategoryPropertyItem item)
 {
     this.Filter = null;
     if (item != null)
     {
         this.SinkId = item.Id;
         CategoryPropertyItem rootItem = ConfigurationAccessHelper.GetCategoryPropertyByPath(item.PropertyItems, CONFIG_FILTER);
         if (rootItem != null)
         {
             try
             {
                 Type filterType = TypeHelper.GetTypeFromString(rootItem.EntryValue, TypeLookupModeEnum.AllowAll, true, true, true);
                 this.Filter = (IErrorReportFilter)filterType.GetConstructor(Type.EmptyTypes).Invoke(new object[] { });
                 this.Filter.Initialize(rootItem);
             }
             catch (Exception ex)
             {
                 this.Filter = null;
                 string message = string.Format("Failed to create error report filter. Type: '{0}'. Sink type: '{1}'", rootItem.EntryValue, this.GetType().AssemblyQualifiedName);
                 if (LOGGER.IsErrorEnabled)
                 {
                     LOGGER.Error(message, ex);
                 }
                 throw new InitializationException(message, ex);
             }
         }
     }
 }
コード例 #8
0
        /// <summary>
        /// Initializes the specified config item.
        /// </summary>
        /// <param name="configItem">The config item.</param>
        /// <exception cref="Forge.Configuration.Shared.InvalidConfigurationValueException">ServerNameOnCertificate value is invalid.</exception>
        public override void Initialize(CategoryPropertyItem configItem)
        {
            if (configItem == null)
            {
                ThrowHelper.ThrowArgumentNullException("configItem");
            }
            if (!IsInitialized)
            {
                mServerNameOnCertificate = ConfigurationAccessHelper.GetValueByPath(configItem.PropertyItems, "ServerNameOnCertificate");
                if (string.IsNullOrEmpty(mServerNameOnCertificate))
                {
                    throw new InvalidConfigurationValueException("ServerNameOnCertificate value is invalid.");
                }

                string skipSslPolicy = ConfigurationAccessHelper.GetValueByPath(configItem.PropertyItems, "SkipSslPolicyErrors");
                if (!string.IsNullOrEmpty(skipSslPolicy))
                {
                    bool value = false;
                    if (bool.TryParse(skipSslPolicy, out value))
                    {
                        mSkipSslPolicyErrors = value;
                    }
                }

                base.Initialize(configItem);

                IsInitialized = true;
            }
        }
コード例 #9
0
ファイル: Channel.cs プロジェクト: ewin66/Forge
        /// <summary>
        /// Creates the message sink.
        /// </summary>
        /// <param name="pi">The pi.</param>
        /// <returns></returns>
        protected IMessageSink CreateMessageSink(CategoryPropertyItem pi)
        {
            if (string.IsNullOrEmpty(pi.EntryValue))
            {
                throw new InvalidConfigurationException("No message sink class definied in a message sink configuration entry.");
            }

            IMessageSink result = null;

            try
            {
                if (LOGGER.IsInfoEnabled)
                {
                    LOGGER.Info(string.Format("Channel, create message sink from type '{0}'. ChannelId: '{1}'.", pi.EntryValue, this.ChannelId));
                }
                Type type = TypeHelper.GetTypeFromString(pi.EntryValue);
                result = (IMessageSink)type.GetConstructor(new Type[] { }).Invoke(null);
                result.Initialize(pi);
            }
            catch (Exception ex)
            {
                throw new InvalidConfigurationException(String.Format("Unable to instantiate message sink '{0}' specified in configuration.", pi.EntryValue), ex);
            }
            return(result);
        }
コード例 #10
0
ファイル: MessageSinkBase.cs プロジェクト: ewin66/Forge
        /// <summary>
        /// Initialize message sink from configuration
        /// </summary>
        /// <param name="pi">The pi.</param>
        public virtual void Initialize(CategoryPropertyItem pi)
        {
            if (pi == null)
            {
                ThrowHelper.ThrowArgumentNullException("pi");
            }

            if (!this.mInitialized)
            {
                CategoryPropertyItem piCompressData = ConfigurationAccessHelper.GetCategoryPropertyByPath(pi.PropertyItems, "CompressData");
                if (piCompressData != null)
                {
                    bool.TryParse(piCompressData.EntryValue, out mCompressData);
                    CategoryPropertyItem piCompressDataOverSize = ConfigurationAccessHelper.GetCategoryPropertyByPath(pi.PropertyItems, "CompressDataOverSize");
                    if (piCompressDataOverSize != null)
                    {
                        int result = 0;
                        if (int.TryParse(piCompressDataOverSize.EntryValue, out result))
                        {
                            mCompressDataOverSize = result;
                        }
                    }
                }
            }
        }
コード例 #11
0
ファイル: BinaryMessageSink.cs プロジェクト: ewin66/Forge
 /// <summary>
 /// Initialize message sink from configuration
 /// </summary>
 /// <param name="pi">The pi.</param>
 public override void Initialize(CategoryPropertyItem pi)
 {
     if (!this.mInitialized)
     {
         base.Initialize(pi);
         this.mInitialized = true;
     }
 }
コード例 #12
0
        private void SectionHandler_OnConfigurationChanged(object sender, EventArgs e)
        {
            string value = ConfigurationAccessHelper.GetValueByPath(TerraGrafConfiguration.Settings.CategoryPropertyItems, "NetworkContext");

            if (string.IsNullOrEmpty(value) || string.IsNullOrEmpty(value.Trim()))
            {
                throw new InitializationException("Network context name not configured.");
            }
            this.mName = value.Trim();

            value = ConfigurationAccessHelper.GetValueByPath(TerraGrafConfiguration.Settings.CategoryPropertyItems, "NetworkContext/Separation");
            bool boolValue = false;

            if (!string.IsNullOrEmpty(value))
            {
                bool.TryParse(value, out boolValue);
            }
            Separation = boolValue;

            CategoryPropertyItem piRoot = ConfigurationAccessHelper.GetCategoryPropertyByPath(TerraGrafConfiguration.Settings.CategoryPropertyItems, "NetworkContext/Separation/WhiteList");
            List <ContextRule>   list   = new List <ContextRule>();

            if (piRoot != null)
            {
                foreach (CategoryPropertyItem pi in piRoot)
                {
                    if (string.IsNullOrEmpty(pi.EntryName) || string.IsNullOrEmpty(pi.EntryName.Trim()))
                    {
                        throw new InitializationException("Invalid context rule.");
                    }
                    if (string.IsNullOrEmpty(pi.EntryValue) || string.IsNullOrEmpty(pi.EntryValue.Trim()))
                    {
                        throw new InitializationException("Invalid context rule.");
                    }
                    list.Add(new ContextRule(pi.EntryName, pi.EntryValue));
                }
            }
            WhiteList = list;

            piRoot = ConfigurationAccessHelper.GetCategoryPropertyByPath(TerraGrafConfiguration.Settings.CategoryPropertyItems, "NetworkContext/Separation/BlackList");
            list   = new List <ContextRule>();
            if (piRoot != null)
            {
                foreach (CategoryPropertyItem pi in piRoot)
                {
                    if (string.IsNullOrEmpty(pi.EntryName) || string.IsNullOrEmpty(pi.EntryName.Trim()))
                    {
                        throw new InitializationException("Invalid context rule.");
                    }
                    if (string.IsNullOrEmpty(pi.EntryValue) || string.IsNullOrEmpty(pi.EntryValue.Trim()))
                    {
                        throw new InitializationException("Invalid context rule.");
                    }
                    list.Add(new ContextRule(pi.EntryName, pi.EntryValue));
                }
            }
            BlackList = list;
        }
コード例 #13
0
ファイル: FailSafeFactory.cs プロジェクト: ewin66/Forge
        /// <summary>
        /// Fails the safe start storage provider.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="storageId">The storage id.</param>
        /// <param name="dataFormatter">The data formatter.</param>
        /// <param name="compressContent">if set to <c>true</c> [compress content].</param>
        /// <param name="enableReset">if set to <c>true</c> [enable reset].</param>
        /// <param name="hasError">if set to <c>true</c> [has error].</param>
        /// <returns></returns>
        public static HibernateStorageProvider <T> FailSafeStartStorageProvider <T>(string storageId, IDataFormatter <T> dataFormatter, bool compressContent, bool enableReset, out bool hasError)
        {
            HibernateStorageProvider <T> result = null;

            hasError = false;

            try
            {
                result = new HibernateStorageProvider <T>(storageId, dataFormatter, compressContent);
                IEnumeratorSpecialized <T> iterator = result.GetEnumerator();
                while (iterator.MoveNext())
                {
                    // check data consistency
                }
            }
            catch (Exception ex)
            {
                if (LOGGER.IsErrorEnabled)
                {
                    LOGGER.Error(string.Format("NHIBERNATE_STORAGE_PROVIDER, failed to initialize storage provider: '{0}'. Reset allowed: {1}", storageId, enableReset.ToString()), ex);
                }
                hasError = true;
                if (enableReset)
                {
                    // reset the content of the storage provider
                    CategoryPropertyItem root       = ConfigurationAccessHelper.GetCategoryPropertyByPath(StorageConfiguration.Settings.CategoryPropertyItems, "NHibernateProvider");
                    CategoryPropertyItem removeItem = ConfigurationAccessHelper.GetCategoryPropertyByPath(root.PropertyItems, "KnownStorageIdsToReset");
                    if (removeItem == null)
                    {
                        removeItem    = new CategoryPropertyItem();
                        removeItem.Id = "KnownStorageIdsToReset";
                        root.PropertyItems.Add(removeItem);
                    }

                    CategoryPropertyItem storeItem = ConfigurationAccessHelper.GetCategoryPropertyByPath(removeItem.PropertyItems, storageId);
                    if (storeItem == null)
                    {
                        storeItem    = new CategoryPropertyItem();
                        storeItem.Id = storageId;
                        removeItem.PropertyItems.Add(storeItem);
                        try
                        {
                            result = new HibernateStorageProvider <T>(storageId, dataFormatter, compressContent);
                        }
                        finally
                        {
                            removeItem.PropertyItems.Remove(storeItem);
                        }
                    }
                }
                else
                {
                    throw;
                }
            }

            return(result);
        }
コード例 #14
0
ファイル: StreamFactoryBase.cs プロジェクト: ewin66/Forge
        /// <summary>
        /// Parses the string value.
        /// </summary>
        /// <param name="root">The root.</param>
        /// <param name="entryId">The entry id.</param>
        /// <param name="defaultValue">The default value.</param>
        /// <returns>True, if the parse method was succeeded, otherwise False.</returns>
        protected static String ParseStringValue(CategoryPropertyItem root, String entryId, String defaultValue)
        {
            String result           = defaultValue;
            CategoryPropertyItem pi = ConfigurationAccessHelper.GetCategoryPropertyByPath(root.PropertyItems, entryId);

            if (pi != null)
            {
                result = pi.EntryValue;
            }
            return(result);
        }
コード例 #15
0
        /// <summary>
        /// Creates the category property item.
        /// </summary>
        /// <returns></returns>
        public CategoryPropertyItem CreateCategoryPropertyItem()
        {
            CategoryPropertyItem result = new CategoryPropertyItem();

            result.Id            = this.Id;
            result.EntryValue    = this.Value;
            result.PropertyItems = new CategoryPropertyItems();
            foreach (PropertyItem pi in this.PropertyItems.Values)
            {
                result.PropertyItems.Add(pi.CreateCategoryPropertyItem());
            }

            return(result);
        }
コード例 #16
0
ファイル: FileStorageProvider.cs プロジェクト: ewin66/Forge
        /// <summary>
        /// Initializes a new instance of the <see cref="FileStorageProvider&lt;T&gt;"/> class.
        /// </summary>
        /// <param name="storageId">The storage id.</param>
        /// <param name="configItem">The config item.</param>
        public FileStorageProvider(String storageId, CategoryPropertyItem configItem)
            : base(storageId, configItem)
        {
            String url = String.Empty;
            CategoryPropertyItem item = configItem.PropertyItems == null ? null : configItem.PropertyItems["BaseUrl"];

            if (item != null)
            {
                url = item.EntryValue;
            }
            this.mBaseUrl = url;

            Initialize();
        }
コード例 #17
0
ファイル: NATGatewaySettings.cs プロジェクト: ewin66/Forge
        private void SectionHandler_OnConfigurationChanged(object sender, EventArgs e)
        {
            CategoryPropertyItem   piRoot = ConfigurationAccessHelper.GetCategoryPropertyByPath(TerraGrafConfiguration.Settings.CategoryPropertyItems, "NetworkPeering/NAT_Gateways");
            List <AddressEndPoint> list   = new List <AddressEndPoint>();

            if (piRoot != null)
            {
                foreach (CategoryPropertyItem pi in piRoot)
                {
                    list.Add(AddressEndPoint.Parse(pi.EntryValue));
                }
            }
            EndPoints = list;
        }
コード例 #18
0
        /// <summary>
        /// Initializes the specified config item.
        /// </summary>
        /// <param name="configItem">The config item.</param>
        /// <exception cref="InitializationException">Administration connection string was not set.</exception>
        /// <exception cref="Forge.InitializationException">Administration connection string was not set.</exception>
        public void Initialize(CategoryPropertyItem configItem)
        {
            if (configItem == null)
            {
                ThrowHelper.ThrowArgumentNullException("configItem");
            }

            mConnectionStringForAdmin = ConfigurationAccessHelper.GetValueByPath(configItem.PropertyItems, CONNECTION_STRING_CONFIG_ID);
            if (string.IsNullOrEmpty(mConnectionStringForAdmin))
            {
                throw new InitializationException("Administration connection string was not set.");
            }

            this.IsInitialized = true;
        }
コード例 #19
0
        private static void SectionHandler_OnConfigurationChanged(object sender, EventArgs e)
        {
            CategoryPropertyItem rootItem = ConfigurationAccessHelper.GetCategoryPropertyByPath(RemoteDesktopConfiguration.Settings.CategoryPropertyItems, CONFIG_ROOT);

            if (rootItem != null)
            {
                int mouseMoveSendingInterval = Consts.DEFAULT_MOUSE_MOVE_SEND_INTERVAL;
                if (ConfigurationAccessHelper.ParseIntValue(rootItem.PropertyItems, CONFIG_MOUSE_MOVE_SEND_INTERVAL, 0, int.MaxValue, ref mouseMoveSendingInterval))
                {
                    MouseMoveSendInterval = mouseMoveSendingInterval;
                }
            }

            Raiser.CallDelegatorBySync(EventConfigurationChanged, new object[] { null, EventArgs.Empty });
        }
コード例 #20
0
ファイル: FilterBase.cs プロジェクト: ewin66/Forge
        /// <summary>
        /// Initializes the specified item.
        /// </summary>
        /// <param name="item">The item.</param>
        public virtual void Initialize(CategoryPropertyItem item)
        {
            if (item == null)
            {
                ThrowHelper.ThrowArgumentNullException("item");
            }

            if (item.PropertyItems != null)
            {
                bool negation = false;
                if (ConfigurationAccessHelper.ParseBooleanValue(item.PropertyItems, CONFIG_NEGATION, ref negation))
                {
                    this.Negation = negation;
                }
            }
        }
コード例 #21
0
ファイル: LikeFilter.cs プロジェクト: ewin66/Forge
        /// <summary>
        /// Initializes the specified item.
        /// </summary>
        /// <param name="item">The item.</param>
        public override void Initialize(CategoryPropertyItem item)
        {
            base.Initialize(item);

            this.MatchMode = LikeMatchModeFilterEnum.Exact;
            if (item.PropertyItems != null)
            {
                LikeMatchModeFilterEnum matchMode = LikeMatchModeFilterEnum.Exact;
                if (ConfigurationAccessHelper.ParseEnumValue <LikeMatchModeFilterEnum>(item.PropertyItems, CONFIG_MATCHMODE, ref matchMode))
                {
                    this.MatchMode = matchMode;
                }
            }

            this.IsInitialized = true;
        }
コード例 #22
0
ファイル: ArithmeticFilter.cs プロジェクト: ewin66/Forge
        /// <summary>
        /// Initializes the specified item.
        /// </summary>
        /// <param name="item">The item.</param>
        public override void Initialize(CategoryPropertyItem item)
        {
            base.Initialize(item);

            this.Operand = ArithmeticFilterOperandEnum.Equal;
            if (item.PropertyItems != null)
            {
                ArithmeticFilterOperandEnum operand = ArithmeticFilterOperandEnum.Equal;
                if (ConfigurationAccessHelper.ParseEnumValue <ArithmeticFilterOperandEnum>(item.PropertyItems, CONFIG_OPERAND, ref operand))
                {
                    this.Operand = operand;
                }
            }

            this.IsInitialized = true;
        }
コード例 #23
0
ファイル: StreamFactoryBase.cs プロジェクト: ewin66/Forge
        /// <summary>
        /// Parses the enum value.
        /// </summary>
        /// <typeparam name="TEnum">The type of the enum.</typeparam>
        /// <param name="root">The root.</param>
        /// <param name="entryId">The entry unique identifier.</param>
        /// <returns></returns>
        protected static TEnum ParseEnumValue <TEnum>(CategoryPropertyItem root, String entryId) where TEnum : struct
        {
            TEnum result            = default(TEnum);
            CategoryPropertyItem pi = ConfigurationAccessHelper.GetCategoryPropertyByPath(root.PropertyItems, entryId);

            if (pi != null)
            {
                try
                {
                    result = (TEnum)Enum.Parse(typeof(TEnum), pi.EntryValue, true);
                }
                catch (Exception)
                {
                }
            }
            return(result);
        }
コード例 #24
0
ファイル: StreamFactoryBase.cs プロジェクト: ewin66/Forge
        /// <summary>
        /// Parses the boolean value.
        /// </summary>
        /// <param name="root">The root.</param>
        /// <param name="entryId">The entry id.</param>
        /// <returns>True, if the parse method was succeeded, otherwise False.</returns>
        protected static bool ParseBooleanValue(CategoryPropertyItem root, String entryId)
        {
            bool result             = false;
            CategoryPropertyItem pi = ConfigurationAccessHelper.GetCategoryPropertyByPath(root.PropertyItems, entryId);

            if (pi != null)
            {
                try
                {
                    result = bool.Parse(pi.EntryValue);
                }
                catch (Exception)
                {
                }
            }
            return(result);
        }
コード例 #25
0
        /// <summary>
        /// Initializes the <see cref="HibernateStorageProvider&lt;T&gt;"/> class.
        /// </summary>
        static HibernateStorageProvider()
        {
            SYSTEM_ID = HashGeneratorHelper.GetSHA256BasedValue(ApplicationHelper.ApplicationId);

            CategoryPropertyItem configItem = ConfigurationAccessHelper.GetCategoryPropertyByPath(StorageConfiguration.Settings.CategoryPropertyItems, "NHibernateProvider/NHibernateStorages/Default");

            if (configItem != null)
            {
                DEFAULT_SESSION_FACTORY = CreateEntityManagerFactory(configItem);
            }

            configItem = ConfigurationAccessHelper.GetCategoryPropertyByPath(StorageConfiguration.Settings.CategoryPropertyItems, "NHibernateProvider/NHibernateStorages/StorageSpecified");
            if (configItem != null)
            {
                foreach (CategoryPropertyItem pi in configItem)
                {
                    mSessionFactoriesForStorages.Add(configItem.Id, CreateEntityManagerFactory(configItem));
                }
            }
        }
コード例 #26
0
        private void SectionHandler_OnConfigurationChanged(object sender, EventArgs e)
        {
            CategoryPropertyItem   piRoot = ConfigurationAccessHelper.GetCategoryPropertyByPath(TerraGrafConfiguration.Settings.CategoryPropertyItems, "NetworkPeering/TCP_Connections");
            List <ConnectionEntry> list   = new List <ConnectionEntry>();

            if (piRoot != null)
            {
                foreach (CategoryPropertyItem pi in piRoot)
                {
                    AddressEndPoint address    = AddressEndPoint.Parse(pi.EntryValue);
                    bool            reConnect  = true;
                    int             delayValue = 1000;
                    int             conTimeout = Timeout.Infinite;
                    string          item       = ConfigurationAccessHelper.GetValueByPath(TerraGrafConfiguration.Settings.CategoryPropertyItems, string.Format("NetworkPeering/TCP_Connections/{0}/ReconnectOnFailure", pi.Id));
                    if (!string.IsNullOrEmpty(item))
                    {
                        bool.TryParse(item, out reConnect);
                    }
                    item = ConfigurationAccessHelper.GetValueByPath(TerraGrafConfiguration.Settings.CategoryPropertyItems, string.Format("NetworkPeering/TCP_Connections/{0}/DelayBetweenAttempsInMS", pi.Id));
                    if (!string.IsNullOrEmpty(item))
                    {
                        int.TryParse(item, out delayValue);
                        if (delayValue < 0)
                        {
                            delayValue = 1000;
                        }
                    }
                    item = ConfigurationAccessHelper.GetValueByPath(TerraGrafConfiguration.Settings.CategoryPropertyItems, string.Format("NetworkPeering/TCP_Connections/{0}/ConnectionTimeout", pi.Id));
                    if (!string.IsNullOrEmpty(item))
                    {
                        int.TryParse(item, out conTimeout);
                        if (conTimeout < Timeout.Infinite)
                        {
                            conTimeout = Timeout.Infinite;
                        }
                    }
                    list.Add(new ConnectionEntry(address, reConnect, delayValue, conTimeout));
                }
            }
            EndPoints = list;
        }
コード例 #27
0
ファイル: Channel.cs プロジェクト: ewin66/Forge
        /// <summary>
        /// Initializes the channel.
        /// </summary>
        /// <param name="pi">The pi.</param>
        public virtual void Initialize(CategoryPropertyItem pi)
        {
            DoDisposeCheck();
            if (pi == null)
            {
                ThrowHelper.ThrowArgumentNullException("pi");
            }

            if (!mInitialized)
            {
                {
                    this.mConnectionData = null;
                    CategoryPropertyItem item = ConfigurationAccessHelper.GetCategoryPropertyByPath(pi.PropertyItems, "RemoteAddress");
                    if (item != null)
                    {
                        this.mConnectionData = AddressEndPoint.Parse(item.EntryValue);
                    }
                    if (item != null)
                    {
                        ConfigurationAccessHelper.ParseLongValue(pi.PropertyItems, "DefaultErrorResponseTimeout", Timeout.Infinite, long.MaxValue, ref mDefaultErrorResponseTimeout);
                    }
                }
                {
                    mServerEndpoints.Clear();
                    CategoryPropertyItem baseAddressesItems = ConfigurationAccessHelper.GetCategoryPropertyByPath(pi.PropertyItems, "BaseAddresses");
                    if (baseAddressesItems != null)
                    {
                        IEnumerator <CategoryPropertyItem> iterator = baseAddressesItems.GetEnumerator();
                        while (iterator.MoveNext())
                        {
                            mServerEndpoints.Add(AddressEndPoint.Parse(iterator.Current.EntryValue));
                        }
                    }
                }
                {
                    mSessionReusable = true;
                    ConfigurationAccessHelper.ParseBooleanValue(pi.PropertyItems, "SessionReusable", ref mSessionReusable);
                }
            }
        }
コード例 #28
0
        /// <summary>
        /// Initializes the specified item.
        /// </summary>
        /// <param name="item">The item.</param>
        public override void Initialize(CategoryPropertyItem item)
        {
            base.Initialize(item);

            this.FilterLogic = GroupFilterLoginEnum.And;
            mFilters.Clear();
            if (item.PropertyItems != null)
            {
                GroupFilterLoginEnum logic = GroupFilterLoginEnum.And;
                if (ConfigurationAccessHelper.ParseEnumValue <GroupFilterLoginEnum>(item.PropertyItems, CONFIG_FILTER_LOGIC, ref logic))
                {
                    this.FilterLogic = logic;
                }

                CategoryPropertyItem filterItems = ConfigurationAccessHelper.GetCategoryPropertyByPath(item.PropertyItems, CONFIG_FILTERS);
                if (filterItems != null && filterItems.PropertyItems != null)
                {
                    foreach (CategoryPropertyItem filterItem in filterItems.PropertyItems)
                    {
                        try
                        {
                            Type filterType           = TypeHelper.GetTypeFromString(filterItem.EntryValue, TypeLookupModeEnum.AllowAll, true, true, true);
                            IErrorReportFilter filter = (IErrorReportFilter)filterType.GetConstructor(Type.EmptyTypes).Invoke(new object[] { });
                            filter.Initialize(filterItem);
                            mFilters.Add(filter);
                        }
                        catch (Exception ex)
                        {
                            if (LOGGER.IsErrorEnabled)
                            {
                                LOGGER.Error(string.Format("GROUP_FILTER, failed to create error report filter. Type: '{0}'", filterItem.EntryValue), ex);
                            }
                        }
                    }
                }
            }
            this.IsInitialized = true;
        }
コード例 #29
0
        private void SectionHandler_OnConfigurationChanged(object sender, EventArgs e)
        {
            CategoryPropertyItem   piRoot = ConfigurationAccessHelper.GetCategoryPropertyByPath(TerraGrafConfiguration.Settings.CategoryPropertyItems, "NetworkPeering/TCPServers/Auto");
            List <AddressEndPoint> list   = new List <AddressEndPoint>();

            if (piRoot != null)
            {
                foreach (CategoryPropertyItem pi in piRoot)
                {
                    list.Add(AddressEndPoint.Parse(pi.EntryValue));
                }
            }
            EndPoints = list;

            string value     = ConfigurationAccessHelper.GetValueByPath(TerraGrafConfiguration.Settings.CategoryPropertyItems, "NetworkPeering/TCPServers/Auto");
            bool   boolValue = false;

            if (!string.IsNullOrEmpty(value))
            {
                bool.TryParse(value, out boolValue);
            }
            mAuto = boolValue;
        }
コード例 #30
0
        public static void Save(ConfigurationSaveMode saveMode)
        {
            CategoryPropertyItem rootItem = ConfigurationAccessHelper.GetCategoryPropertyByPath(RemoteDesktopConfiguration.Settings.CategoryPropertyItems, CONFIG_ROOT);

            if (rootItem == null)
            {
                rootItem    = new CategoryPropertyItem();
                rootItem.Id = CONFIG_ROOT;
                RemoteDesktopConfiguration.Settings.CategoryPropertyItems.Add(rootItem);
            }

            CategoryPropertyItem piMouseMoveSendingInterval = ConfigurationAccessHelper.GetCategoryPropertyByPath(rootItem.PropertyItems, CONFIG_MOUSE_MOVE_SEND_INTERVAL);

            if (piMouseMoveSendingInterval == null)
            {
                piMouseMoveSendingInterval    = new CategoryPropertyItem();
                piMouseMoveSendingInterval.Id = CONFIG_MOUSE_MOVE_SEND_INTERVAL;
                rootItem.PropertyItems.Add(piMouseMoveSendingInterval);
            }
            piMouseMoveSendingInterval.EntryValue = MouseMoveSendInterval.ToString();

            RemoteDesktopConfiguration.Save(saveMode);
        }
コード例 #31
0
 private void Decrypt(CategoryPropertyItem item)
 {
     item.Encrypted = false;
     foreach (CategoryPropertyItem i in item.PropertyItems)
     {
         Decrypt(i);
     }
 }
コード例 #32
0
ファイル: SQLiteManager.cs プロジェクト: JZO001/Forge
 /// <summary>
 /// Initializes the specified config item.
 /// </summary>
 /// <param name="configItem">The config item.</param>
 public virtual void Initialize(CategoryPropertyItem configItem)
 {
     this.IsInitialized = true;
 }
コード例 #33
0
        /// <summary>
        /// Initializes the specified config item.
        /// </summary>
        /// <param name="configItem">The config item.</param>
        /// <exception cref="InvalidConfigurationValueException">
        /// CertificateSource value is invalid.
        /// or
        /// CertificateSource value is invalid.
        /// or
        /// CertificateFile value is invalid.
        /// or
        /// Password value is invalid.
        /// or
        /// Subject value is invalid.
        /// or
        /// CertificateSource value is invalid.
        /// </exception>
        /// <exception cref="InvalidConfigurationException">
        /// Invalid certificate.
        /// or
        /// Failed to find certificate.
        /// or
        /// Failed to find certificate.
        /// </exception>
        public virtual void Initialize(CategoryPropertyItem configItem)
        {
            if (configItem == null)
            {
                ThrowHelper.ThrowArgumentNullException("configItem");
            }
            if (!mInitialized)
            {
                string certSource = ConfigurationAccessHelper.GetValueByPath(configItem.PropertyItems, "CertificateSource");
                if (string.IsNullOrEmpty(certSource))
                {
                    throw new InvalidConfigurationValueException("CertificateSource value is invalid.");
                }
                certSource = certSource.Trim().ToLower();
                if (string.IsNullOrEmpty(certSource))
                {
                    throw new InvalidConfigurationValueException("CertificateSource value is invalid.");
                }
                if ("file".Equals(certSource))
                {
                    string certFile = ConfigurationAccessHelper.GetValueByPath(configItem.PropertyItems, "CertificateFile");
                    if (string.IsNullOrEmpty(certFile))
                    {
                        throw new InvalidConfigurationValueException("CertificateFile value is invalid.");
                    }
                    FileInfo fi = new FileInfo(certFile);
                    if (!fi.Exists)
                    {
                        throw new InvalidConfigurationException(string.Format("Certificate file not found: {0}", fi.FullName));
                    }

                    string passwordString = ConfigurationAccessHelper.GetValueByPath(configItem.PropertyItems, "Password");
                    if (string.IsNullOrEmpty(passwordString))
                    {
                        throw new InvalidConfigurationValueException("Password value is invalid.");
                    }

                    try
                    {
                        mCertificate = new X509Certificate2(fi.FullName, passwordString);
                    }
                    catch (Exception ex)
                    {
                        throw new InvalidConfigurationException("Invalid certificate.", ex);
                    }
                }
                else if ("store".Equals(certSource))
                {
                    StoreName storeName = StoreName.My;
                    StoreLocation storeLocation = StoreLocation.CurrentUser;
                    string subject = string.Empty;

                    string storeNameStr = ConfigurationAccessHelper.GetValueByPath(configItem.PropertyItems, "StoreName");
                    if (!string.IsNullOrEmpty(storeNameStr))
                    {
                        storeName = (StoreName)Enum.Parse(typeof(StoreName), storeNameStr);
                    }

                    string storeLocationStr = ConfigurationAccessHelper.GetValueByPath(configItem.PropertyItems, "StoreLocation");
                    if (!string.IsNullOrEmpty(storeLocationStr))
                    {
                        storeLocation = (StoreLocation)Enum.Parse(typeof(StoreLocation), storeLocationStr);
                    }

                    subject = ConfigurationAccessHelper.GetValueByPath(configItem.PropertyItems, "Subject");
                    if (string.IsNullOrEmpty(subject))
                    {
                        throw new InvalidConfigurationValueException("Subject value is invalid.");
                    }

                    X509Store store = new X509Store(storeName, storeLocation);
                    store.Open(OpenFlags.ReadOnly);
                    try
                    {
                        foreach (X509Certificate2 c in store.Certificates)
                        {
                            if (c.Subject.Equals(subject))
                            {
                                mCertificate = c;
                                break;
                            }
                        }
                        if (mCertificate == null)
                        {
                            throw new InvalidConfigurationException("Failed to find certificate.");
                        }
                    }
                    catch (InvalidConfigurationException)
                    {
                        throw;
                    }
                    catch (Exception ex)
                    {
                        throw new InvalidConfigurationException("Failed to find certificate.", ex);
                    }
                    finally
                    {
                        store.Close();
                    }
                }
                else
                {
                    throw new InvalidConfigurationValueException("CertificateSource value is invalid.");
                }

                this.mInitialized = true;
            }
        }
コード例 #34
0
ファイル: MsSql2008Manager.cs プロジェクト: JZO001/Forge
        /// <summary>
        /// Initializes the specified config item.
        /// </summary>
        /// <param name="configItem">The config item.</param>
        /// <exception cref="InitializationException">Administration connection string was not set.</exception>
        /// <exception cref="Forge.InitializationException">Administration connection string was not set.</exception>
        public void Initialize(CategoryPropertyItem configItem)
        {
            if (configItem == null)
            {
                ThrowHelper.ThrowArgumentNullException("configItem");
            }

            mConnectionStringForAdmin = ConfigurationAccessHelper.GetValueByPath(configItem.PropertyItems, CONNECTION_STRING_CONFIG_ID);
            if (string.IsNullOrEmpty(mConnectionStringForAdmin))
            {
                throw new InitializationException("Administration connection string was not set.");
            }

            this.IsInitialized = true;
        }
コード例 #35
0
 private void Encrypt(CategoryPropertyItem item)
 {
     item.Encrypted = true;
     foreach (CategoryPropertyItem i in item.PropertyItems)
     {
         Encrypt(i);
     }
 }