Пример #1
0
        internal static ExpirationHint GetExpirationHint(PoolManager poolManager, object dependency, DateTime absoluteExpiration, TimeSpan slidingExpiration)
        {
            ExpirationHint hint = GetExpirationHint(poolManager, absoluteExpiration, slidingExpiration);

            if (hint == null)
            {
                return(GetExpirationHint(poolManager));
            }

            ExpirationHint hint2 = GetExpirationHint(poolManager);

            if (hint2 == null)
            {
                return(hint);
            }


            AggregateExpirationHint aggregateHint = null;

            if (hint2 is AggregateExpirationHint)
            {
                aggregateHint = hint2 as AggregateExpirationHint;
                aggregateHint.Add(hint);

                return(aggregateHint);
            }

            aggregateHint = AggregateExpirationHint.Create(poolManager);
            aggregateHint.Add(hint);
            aggregateHint.Add(hint2);

            return(aggregateHint);
        }
Пример #2
0
        internal AggregateExpirationHint GetRoutableClone(PoolManager poolManager, Address sourceNode)
        {
            if (_hints == null || _hints.Count == 0)
            {
                return(null);
            }

            AggregateExpirationHint hint = Create(poolManager);

            NodeExpiration ne = null;

            for (int i = 0; i < _hints.Count; i++)
            {
                ExpirationHint eh = (ExpirationHint)_hints[i];
                if (!eh.IsRoutable && ne == null)
                {
                    ne = NodeExpiration.Create(poolManager, sourceNode);
                    hint.Add(ne);
                }
                else
                {
                    hint.Add(eh);
                }
            }
            return(hint);
        }
Пример #3
0
        public static ExpirationHint GetExpirationHint(ExpirationPolicy policy, CacheDependency dependency, DateTime absoluteExpiration, TimeSpan slidingExpiration)
        {
            ExpirationHint hint = GetExpirationHint(policy, absoluteExpiration, slidingExpiration);

            if (hint == null)
            {
                return(GetExpirationHint(dependency));
            }

            ExpirationHint hint2 = GetExpirationHint(dependency);

            if (hint2 == null)
            {
                return(hint);
            }


            AggregateExpirationHint aggregateHint = null;

            if (hint2 is AggregateExpirationHint)
            {
                aggregateHint = hint2 as AggregateExpirationHint;
                aggregateHint.Add(hint);

                return(aggregateHint);
            }

            aggregateHint = new AggregateExpirationHint();
            aggregateHint.Add(hint);
            aggregateHint.Add(hint2);

            return(aggregateHint);
        }
Пример #4
0
        internal AggregateExpirationHint GetRoutableClone(Address sourceNode)
        {
            if (_hints == null || _hints.Count == 0)
            {
                return(null);
            }

            AggregateExpirationHint hint = new AggregateExpirationHint();

            NodeExpiration ne = null;

            for (int i = 0; i < _hints.Count; i++)
            {
                ExpirationHint eh = (ExpirationHint)_hints[i];
                if (!eh.IsRoutable && ne == null)
                {
                    ne = new NodeExpiration(sourceNode);
                    hint.Add(ne);
                }
                else
                {
                    hint.Add(eh);
                }
            }
            return(hint);
        }
Пример #5
0
        public static ExpirationHint ReadExpHint(CompactReader reader, PoolManager poolManager)
        {
            ExpirationHintType expHint = ExpirationHintType.Parent;

            expHint = (ExpirationHintType)reader.ReadInt16();

            switch (expHint)
            {
            case ExpirationHintType.NULL:
                return(null);

            case ExpirationHintType.Parent:
                return((ExpirationHint)reader.ReadObject());

            case ExpirationHintType.FixedExpiration:
                var fe = FixedExpiration.Create(poolManager);
                fe.Deserialize(reader);
                return(fe);

            case ExpirationHintType.TTLExpiration:
                var ttle = TTLExpiration.Create(poolManager);
                ((ICompactSerializable)ttle).Deserialize(reader);
                return(ttle);

            case ExpirationHintType.FixedIdleExpiration:
                var fie = FixedIdleExpiration.Create(poolManager);
                ((ICompactSerializable)fie).Deserialize(reader);
                return(fie);

#if !(DEVELOPMENT || CLIENT)
            case ExpirationHintType.NodeExpiration:
                var ne = NodeExpiration.Create(poolManager);
                ((ICompactSerializable)ne).Deserialize(reader);
                return(ne);
#endif
            case ExpirationHintType.IdleExpiration:
                var ie = IdleExpiration.Create(poolManager);
                ((ICompactSerializable)ie).Deserialize(reader);
                return(ie);

            case ExpirationHintType.AggregateExpirationHint:
                var aeh = AggregateExpirationHint.Create(poolManager);
                ((ICompactSerializable)aeh).Deserialize(reader);
                return(aeh);

            case ExpirationHintType.DependencyHint:
                break;

            default:
                break;
            }
            return(null);
        }
Пример #6
0
        /// <summary>
        /// Add an expiration hint to the hints
        /// </summary>
        /// <param name="eh"></param>
        public void Add(ExpirationHint eh)
        {
            lock (this)
            {
                if (!eh.IsRoutable)
                {
                    this.SetBit(NON_ROUTABLE);
                }
                if (eh.IsVariant)
                {
                    this.SetBit(IS_VARIANT);
                }
                eh.SetExpirationEventSink(this);

                AggregateExpirationHint aggregate = eh as AggregateExpirationHint;
                if (aggregate != null)
                {
                    foreach (ExpirationHint expirationHint in aggregate._hints)
                    {
                        _hints.Add(expirationHint);
                    }
                }
                else
                {
                    _hints.Add(eh);
                }

                bool isFixed = false;
                for (int i = _hints.Count - 1; i >= 0; i--)
                {
                    if (isFixed && _hints[i] is FixedExpiration)
                    {
                        var previousFixedExpiration = _hints[i];
                        _hints.RemoveAt(i);
                        previousFixedExpiration.ReturnLeasableToPool();

                        break;
                    }
                    if (!isFixed && _hints[i] is FixedExpiration)
                    {
                        isFixed = true;
                    }
                }
            }
        }
Пример #7
0
 public CacheDependency GetActualCacheDependency(ExpirationHint hint, ref DateTime absoluteExpiration, ref TimeSpan slidingExpiration)
 {
     if (hint != null)
     {
         if (hint is AggregateExpirationHint)
         {
             AggregateExpirationHint aggregate = (AggregateExpirationHint)hint;
             IList <ExpirationHint>  hints     = aggregate.Hints;
             if (hints != null && hints.Count > 0)
             {
                 foreach (ExpirationHint h in hints)
                 {
                     CacheDependency cacheDep = GetActualCacheDependency(h, ref absoluteExpiration, ref slidingExpiration);
                     if (cacheDep != null && !(cacheDep is Runtime.Dependencies.AggregateCacheDependency))
                     {
                         aggregateList.Add(cacheDep);
                     }
                 }
                 if (aggregateList.Count >= 2)
                 {
                     Runtime.Dependencies.AggregateCacheDependency aggDep = new Runtime.Dependencies.AggregateCacheDependency();
                     aggDep.Add(aggregateList.ToArray());
                     return(aggDep);
                 }
                 else
                 {
                     return(aggregateList[0]);
                 }
             }
         }
         else if (hint is FixedExpiration)
         {
             absoluteExpiration = ((FixedExpiration)hint).AbsoluteTime;
         }
         else if (hint is IdleExpiration)
         {
             slidingExpiration = ((IdleExpiration)hint).SlidingTime;
         }
         else
         {
             return(GetNonAggregateDependencies(hint));
         }
     }
     return(null);
 }
Пример #8
0
 protected static void Construct(AggregateExpirationHint expirationHint, params ExpirationHint[] hints)
 {
     expirationHint?.Initialize(hints);
 }
Пример #9
0
        private static ExpirationHint GetExpirationHint(CacheDependency cacheDependency, AggregateExpirationHint aggregateHint)
        {
            if (cacheDependency == null)
            {
                return(null);
            }

            ExpirationHint hint = null;

            if (cacheDependency is Runtime.Dependencies.KeyDependency)
            {
                Runtime.Dependencies.KeyDependency keyDependency = cacheDependency as Runtime.Dependencies.KeyDependency;
                hint = new KeyDependency(keyDependency.CacheKeys, new DateTime(keyDependency.StartAfterTicks));

                aggregateHint.Add(hint);
            }


            else if (cacheDependency is Runtime.Dependencies.FileDependency)
            {
                Runtime.Dependencies.FileDependency fileDependency = cacheDependency as Runtime.Dependencies.FileDependency;

                hint = new FileDependency(fileDependency.fileNames, new DateTime(fileDependency.StartAfterTicks));

                aggregateHint.Add(hint);
            }

            else if (cacheDependency is Runtime.Dependencies.DBCacheDependency)
            {
                Runtime.Dependencies.DBCacheDependency dbDependency = cacheDependency as Runtime.Dependencies.DBCacheDependency;

                switch (dbDependency.Type)
                {
                case Runtime.Dependencies.DBDependencyType.OleDbCacheDependency:
                    hint = new OleDbCacheDependency(dbDependency.ConnectionString, dbDependency.PrimaryKey);
                    break;

                case Runtime.Dependencies.DBDependencyType.SqlCacheDependency:
                    hint = new Sql7CacheDependency(dbDependency.ConnectionString, dbDependency.PrimaryKey);
                    break;
                }

                aggregateHint.Add(hint);
            }


            else if (cacheDependency is Runtime.Dependencies.OracleCacheDependency)
            {
                Runtime.Dependencies.OracleCacheDependency oracleDependency = cacheDependency as Runtime.Dependencies.OracleCacheDependency;

                Hashtable parameters = new Hashtable();
                if (oracleDependency.CommandParams != null)
                {
                    foreach (KeyValuePair <string, Runtime.Dependencies.OracleCmdParams> pair in oracleDependency.CommandParams)
                    {
                        Runtime.Dependencies.OracleCmdParams oracleCommandParams = pair.Value;
                        OracleCommandParams commandParam = new OracleCommandParams((OracleCmdParamsType)oracleCommandParams.Type, oracleCommandParams.Value, oracleCommandParams.Direction);
                        parameters.Add(pair.Key, commandParam);
                    }
                }

                hint = new OracleCacheDependency(oracleDependency.ConnectionString, oracleDependency.CommandText, oracleDependency.CommandType, parameters);
                aggregateHint.Add(hint);
            }



            else if (cacheDependency is Runtime.Dependencies.SqlCacheDependency)
            {
                Runtime.Dependencies.SqlCacheDependency sqlDependency = cacheDependency as Runtime.Dependencies.SqlCacheDependency;

                Hashtable parameters = new Hashtable();

                if (sqlDependency.CommandParams != null)
                {
                    foreach (KeyValuePair <string, Runtime.Dependencies.SqlCmdParams> pair in sqlDependency.CommandParams)
                    {
                        Runtime.Dependencies.SqlCmdParams param = pair.Value;

                        Alachisoft.NCache.Caching.AutoExpiration.SqlCmdParams commandParam = new SqlCmdParams();
                        commandParam.CmpInfo                 = param.SqlCmpInfo;
                        commandParam.Direction               = param.SqlParamDir;
                        commandParam.IsNullable              = param.IsNullable;
                        commandParam.LocaleID                = param.LocaleID;
                        commandParam.Offset                  = param.Offset;
                        commandParam.Precision               = param.Precision;
                        commandParam.Scale                   = param.Scale;
                        commandParam.ParamSize               = param.Size;
                        commandParam.SourceColumn            = param.SourceColumn;
                        commandParam.SourceColumnNullMapping = param.SourceColumnNullMapping;
                        commandParam.SqlValue                = param.SqlValue;
                        commandParam.SrcVersion              = param.SrcVersion;
                        commandParam.DbType                  = (SqlDbType)param.Type;
                        commandParam.TypeName                = param.TypeName;
                        commandParam.UdtName                 = param.UdtTypeName;
                        commandParam.Value                   = param.Value;
                        parameters.Add(pair.Key, commandParam);
                    }
                }

                hint = new SqlYukonCacheDependency(sqlDependency.ConnectionString, sqlDependency.CommandText, sqlDependency.CommandType, parameters);
                aggregateHint.Add(hint);
            }


            else if (cacheDependency is Runtime.Dependencies.ExtensibleDependency)
            {
                hint = new ExtensibleDependency(cacheDependency as Runtime.Dependencies.ExtensibleDependency);

                aggregateHint.Add(hint);
            }
            else if (cacheDependency is NosDBDependency)
            {
                NosDBDependency nosDbDependency = cacheDependency as NosDBDependency;
                hint = new NosDBCacheDependency(nosDbDependency.ConnectionString, nosDbDependency.CommandText, nosDbDependency.Timeout, nosDbDependency.Parameters);
                aggregateHint.Add(hint);
            }
            else
            {
                foreach (CacheDependency dep in cacheDependency.Dependencies)
                {
                    hint = GetExpirationHint(dep, aggregateHint);
                }
            }
            IList <ExpirationHint> hints = aggregateHint.Hints;

            if (hints.Count == 0)
            {
                return(null);
            }

            if (hints.Count == 1)
            {
                return(hints[0]);
            }

            return(aggregateHint);
        }
Пример #10
0
        public static ExpirationHint GetExpirationHint(CacheDependency dependency)
        {
            AggregateExpirationHint aggregateHint = new AggregateExpirationHint();

            return(GetExpirationHint(dependency, aggregateHint));
        }
Пример #11
0
        public static CacheDependency GetCacheDependency(ExpirationHint hint, ref DateTime absoluteExpiration, ref TimeSpan slidingExpiration)
        {
            CacheDependency cacheDependency = null;

            if (hint != null)
            {
                if (hint is AggregateExpirationHint)
                {
                    AggregateExpirationHint aggregate = (AggregateExpirationHint)hint;
                    IList <ExpirationHint>  hints     = aggregate.Hints;
                    if (hints != null && hints.Count > 0)
                    {
                        foreach (ExpirationHint h in hints)
                        {
                            AddToDependency(ref cacheDependency, GetCacheDependency(h, ref absoluteExpiration, ref slidingExpiration));
                        }
                    }
                }

                else if (hint is FixedExpiration)
                {
                    absoluteExpiration = ((FixedExpiration)hint).AbsoluteTime;
                }
                else if (hint is IdleExpiration)
                {
                    slidingExpiration = ((IdleExpiration)hint).SlidingTime;
                }

                else if (hint is KeyDependency)
                {
                    KeyDependency keyDep = (KeyDependency)hint;

                    AddToDependency(ref cacheDependency,
                                    new Runtime.Dependencies.KeyDependency(keyDep.CacheKeys, new DateTime(keyDep.StartAfterTicks)));
                }

                else if (hint is FileDependency)
                {
                    FileDependency fileDep = (FileDependency)hint;

                    AddToDependency(ref cacheDependency, new Runtime.Dependencies.FileDependency(fileDep.fileNames, new DateTime(fileDep.StartAfterTicks)));
                }


                else if (hint is OleDbCacheDependency)
                {
                    OleDbCacheDependency oleDbDep = (OleDbCacheDependency)hint;

                    AddToDependency(ref cacheDependency,
                                    new CacheDependency(null, null, DBDependencyFactory.CreateOleDbCacheDependency(
                                                            oleDbDep.ConnectionString, oleDbDep.DbCacheKey)));
                }



                else if (hint is Sql7CacheDependency)
                {
                    Sql7CacheDependency sql7Dep = (Sql7CacheDependency)hint;
                    AddToDependency(ref cacheDependency,
                                    new CacheDependency(null, null, DBDependencyFactory.CreateSqlCacheDependency(
                                                            sql7Dep.ConnectionString, sql7Dep.DbCacheKey)));
                }



                else if (hint is OracleCacheDependency)
                {
                    OracleCacheDependency oracleDep = (OracleCacheDependency)hint;

                    Dictionary <string, OracleCmdParams> parameters = new Dictionary <string, OracleCmdParams>();
                    IDictionaryEnumerator enu = oracleDep.CommandParams.GetEnumerator();
                    while (enu.MoveNext())
                    {
                        string key = enu.Key.ToString();
                        OracleCommandParams cmdParam = (OracleCommandParams)enu.Value;

                        OracleCmdParams commandParam = new OracleCmdParams();

                        commandParam.Direction = (OracleParameterDirection)cmdParam.Direction;
                        commandParam.Type      = (OracleCmdParamsType)cmdParam.Type;
                        commandParam.Value     = cmdParam.Value;

                        parameters.Add(key, commandParam);
                    }

                    Runtime.Dependencies.OracleCacheDependency oraDep = new Runtime.Dependencies.OracleCacheDependency(oracleDep.ConnectionString,
                                                                                                                       oracleDep.QueryString,
                                                                                                                       (OracleCommandType)oracleDep.CommandType,
                                                                                                                       parameters);

                    AddToDependency(ref cacheDependency, oraDep);
                }


                else if (hint is SqlYukonCacheDependency)
                {
                    SqlYukonCacheDependency yukonDep = (SqlYukonCacheDependency)hint;

                    Dictionary <string, Runtime.Dependencies.SqlCmdParams> parameters = new Dictionary <string, Runtime.Dependencies.SqlCmdParams>();
                    IDictionaryEnumerator enu = yukonDep.CommandParams.GetEnumerator();

                    while (enu.MoveNext())
                    {
                        string       key   = enu.Key.ToString();
                        SqlCmdParams param = (SqlCmdParams)enu.Value;
                        Runtime.Dependencies.SqlCmdParams yukonCmdParam = new Runtime.Dependencies.SqlCmdParams();

                        yukonCmdParam.SqlParamDir             = param.Direction;
                        yukonCmdParam.Type                    = (CmdParamsType)param.DbType;
                        yukonCmdParam.IsNullable              = param.IsNullable;
                        yukonCmdParam.LocaleID                = param.LocaleID;
                        yukonCmdParam.Offset                  = param.Offset;
                        yukonCmdParam.Precision               = param.Precision;
                        yukonCmdParam.Scale                   = param.Scale;
                        yukonCmdParam.Size                    = param.ParamSize;
                        yukonCmdParam.SourceColumn            = param.SourceColumn;
                        yukonCmdParam.SourceColumnNullMapping = param.SourceColumnNullMapping;
                        yukonCmdParam.SqlValue                = param.SqlValue;
                        yukonCmdParam.SourceVersion           = (SqlDataRowVersion)(int)param.SrcVersion;
                        yukonCmdParam.TypeName                = param.TypeName;
                        yukonCmdParam.UdtTypeName             = param.UdtName;
                        yukonCmdParam.Value                   = param.Value;

                        parameters.Add(key, yukonCmdParam);
                    }

                    Runtime.Dependencies.SqlCacheDependency sqlDep = new Runtime.Dependencies.SqlCacheDependency(yukonDep.ConnectionString,
                                                                                                                 yukonDep.QueryString,
                                                                                                                 (SqlCommandType)yukonDep.CommandType,
                                                                                                                 parameters);

                    AddToDependency(ref cacheDependency, sqlDep);
                }
                else if (hint is NosDBCacheDependency)
                {
                    NosDBCacheDependency nosDbDep = (NosDBCacheDependency)hint;

                    Dictionary <string, object> parameters = new Dictionary <string, object>();
                    IDictionaryEnumerator       enu        = nosDbDep.CommandParams.GetEnumerator();
                    while (enu.MoveNext())
                    {
                        string key = enu.Key.ToString();
                        parameters.Add(key, enu.Value);
                    }
                    NosDBDependency nosDb = new NosDBDependency(nosDbDep.ConnectionString, nosDbDep.QueryString, parameters, nosDbDep.Timeout);
                    AddToDependency(ref cacheDependency, nosDb);
                }
            }

            return(cacheDependency);
        }
Пример #12
0
 private static ExpirationHint GetExpirationHint(PoolManager poolManager, AggregateExpirationHint aggregateHint)
 {
     return(null);
 }
Пример #13
0
        internal static ExpirationHint GetExpirationHint(PoolManager poolManager)
        {
            AggregateExpirationHint aggregateHint = AggregateExpirationHint.Create(poolManager);

            return(GetExpirationHint(poolManager, aggregateHint));
        }
Пример #14
0
        public static ExpirationHint ReadExpHint(CompactReader reader)
        {
            ExpirationHintType expHint = ExpirationHintType.Parent;

            expHint = (ExpirationHintType)reader.ReadInt16();
            ExpirationHint tmpObj = null;

            switch (expHint)
            {
            case ExpirationHintType.NULL:
                return(null);

            case ExpirationHintType.Parent:
                tmpObj = (ExpirationHint)reader.ReadObject();
                return((ExpirationHint)tmpObj);

            case ExpirationHintType.FixedExpiration:
                FixedExpiration fe = new FixedExpiration();
                ((ICompactSerializable)fe).Deserialize(reader);
                return((ExpirationHint)fe);

            case ExpirationHintType.TTLExpiration:
                TTLExpiration ttle = new TTLExpiration();
                ((ICompactSerializable)ttle).Deserialize(reader);
                return((ExpirationHint)ttle);

            case ExpirationHintType.TTLIdleExpiration:
                TTLIdleExpiration ttlie = new TTLIdleExpiration();
                ((ICompactSerializable)ttlie).Deserialize(reader);
                return((ExpirationHint)ttlie);

            case ExpirationHintType.FixedIdleExpiration:
                FixedIdleExpiration fie = new FixedIdleExpiration();
                ((ICompactSerializable)fie).Deserialize(reader);
                return((ExpirationHint)fie);

            case ExpirationHintType.FileDependency:
                FileDependency fd = new FileDependency();
                ((ICompactSerializable)fd).Deserialize(reader);
                return((ExpirationHint)fd);

            case ExpirationHintType.KeyDependency:
                KeyDependency kd = new KeyDependency();
                ((ICompactSerializable)kd).Deserialize(reader);
                return((ExpirationHint)kd);

#if !(DEVELOPMENT || CLIENT)
            case ExpirationHintType.NodeExpiration:
                NodeExpiration ne = new NodeExpiration();
                ((ICompactSerializable)ne).Deserialize(reader);
                return((ExpirationHint)ne);
#endif
            case ExpirationHintType.Sql7CacheDependency:
                Sql7CacheDependency s7cd = new Sql7CacheDependency();
                ((ICompactSerializable)s7cd).Deserialize(reader);
                return((ExpirationHint)s7cd);

            case ExpirationHintType.OleDbCacheDependency:
                OleDbCacheDependency oledbDependency = new OleDbCacheDependency();
                ((ICompactSerializable)oledbDependency).Deserialize(reader);
                return((ExpirationHint)oledbDependency);

            case ExpirationHintType.SqlYukonCacheDependency:
                SqlYukonCacheDependency sycd = new SqlYukonCacheDependency();
                ((ICompactSerializable)sycd).Deserialize(reader);
                return((ExpirationHint)sycd);

            case ExpirationHintType.OracleCacheDependency:
                OracleCacheDependency orclcd = new OracleCacheDependency();
                ((ICompactSerializable)orclcd).Deserialize(reader);
                return((ExpirationHint)orclcd);


            case ExpirationHintType.IdleExpiration:
                IdleExpiration ie = new IdleExpiration();
                ((ICompactSerializable)ie).Deserialize(reader);
                return((ExpirationHint)ie);

            case ExpirationHintType.AggregateExpirationHint:
                AggregateExpirationHint aeh = new AggregateExpirationHint();
                ((ICompactSerializable)aeh).Deserialize(reader);
                return((ExpirationHint)aeh);

            case ExpirationHintType.DBCacheDependency:
                DBCacheDependency dbcd = new DBCacheDependency();
                ((ICompactSerializable)dbcd).Deserialize(reader);
                return((ExpirationHint)dbcd);

            case ExpirationHintType.ExtensibleDependency:
                ExtensibleDependency ed = new ExtensibleDependency();
                ed = (ExtensibleDependency)reader.ReadObject();
                return((ExpirationHint)ed);

            case ExpirationHintType.NosDBCacheDependency:
                NosDBCacheDependency nosDbd = new NosDBCacheDependency();
                ((ICompactSerializable)nosDbd).Deserialize(reader);
                return(nosDbd);

            case ExpirationHintType.DependencyHint:
                break;

            default:
                break;
            }
            return(null);
        }