Exemplo n.º 1
0
        internal override bool AddInternal(object key, ExpirationHint expirationHint, OperationContext operationContext)
        {
            if (_cacheStore == null)
            {
                throw new InvalidOperationException();
            }
            CacheEntry item = (CacheEntry)_cacheStore.Get(key);

            if (item == null)
            {
                return(false);
            }
            if (item.ExpirationHint == null)
            {
                item.ExpirationHint = expirationHint;
            }
            else if (item.ExpirationHint is AggregateExpirationHint)
            {
                ((AggregateExpirationHint)item.ExpirationHint).Add(expirationHint);
            }
            else
            {
                AggregateExpirationHint hint = new AggregateExpirationHint();
                hint.Add(item.ExpirationHint);
                hint.Add(expirationHint);
                item.ExpirationHint = hint;
            }
            _cacheStore.Insert(key, item);
            item.LastModifiedTime = DateTime.Now;
            return(true);
        }
Exemplo n.º 2
0
        internal override bool RemoveInternal(object key, ExpirationHint eh)
        {
            if (_cacheStore == null)
            {
                throw new InvalidOperationException();
            }
            CacheEntry item = (CacheEntry)_cacheStore.Get(key);

            if ((item == null) || (item.ExpirationHint == null))
            {
                return(false);
            }
            if (item.ExpirationHint is AggregateExpirationHint)
            {
                AggregateExpirationHint hint           = new AggregateExpirationHint();
                AggregateExpirationHint expirationHint = (AggregateExpirationHint)item.ExpirationHint;
                foreach (ExpirationHint hint3 in expirationHint)
                {
                    if (!hint3.Equals(eh))
                    {
                        hint.Add(hint3);
                    }
                }
                item.ExpirationHint = hint;
            }
            else if (item.ExpirationHint.Equals(eh))
            {
                item.ExpirationHint = null;
            }
            _cacheStore.Insert(key, item);
            item.LastModifiedTime = DateTime.Now;
            return(true);
        }
Exemplo n.º 3
0
        /// <summary>
        /// Creates a new object that is a copy of the current instance and that is routable as well.
        /// </summary>
        /// <returns>A routable copy of this instance.</returns>
        internal CacheEntry RoutableClone(Address localAddress)
        {
            lock (this)
            {
                if (_syncDependency != null || _exh != null)
                {
                    //see if expiration hint itself is non-routable then we only need
                    //a node expiration to handle both the syncDependency and expiration.
                    //otherwise we need a node expiration for syncDependency and also need to
                    //maintain the actual routable expiration hint.

                    NodeExpiration expiry = null;
                    if (localAddress != null)
                    {
                        expiry = new NodeExpiration(localAddress);
                    }

                    if (SyncDependency == null)
                    {
                        if (!_exh.IsRoutable)
                        {
                            CacheEntry e = new CacheEntry(Value, expiry, _evh);
                            if (_grpInfo != null)
                            {
                                e._grpInfo = (GroupInfo)_grpInfo.Clone();
                            }
                            e._bitset           = (BitSet)_bitset.Clone();
                            e._version          = this._version;
                            e._creationTime     = this._creationTime;
                            e._lastModifiedTime = this._lastModifiedTime;

                            if (this.LockMetaInfo != null)
                            {
                                e.LockExpiration = this.LockExpiration;
                            }

                            e._resyncProviderName  = this._resyncProviderName;
                            e.Priority             = Priority;
                            e._itemRemovedListener = _itemRemovedListener;
                            e._itemUpdateListener  = _itemUpdateListener;                            return(e);
                        }
                    }
                    else
                    {
                        if (_exh != null && _exh.IsRoutable)
                        {
                            AggregateExpirationHint aggHint = new AggregateExpirationHint();

                            aggHint.Add(_exh);

                            CacheEntry e = new CacheEntry(Value, aggHint, _evh);
                            if (_grpInfo != null)
                            {
                                e._grpInfo = (GroupInfo)_grpInfo.Clone();
                            }
                            e._bitset           = (BitSet)_bitset.Clone();
                            e._version          = this._version;
                            e._creationTime     = this._creationTime;
                            e._lastModifiedTime = this._lastModifiedTime;

                            if (this.LockMetaInfo != null)
                            {
                                e.LockExpiration = this.LockExpiration;
                            }

                            e._resyncProviderName  = this._resyncProviderName;
                            e.Priority             = Priority;
                            e._itemRemovedListener = _itemRemovedListener;
                            e._itemUpdateListener  = _itemUpdateListener;                            return(e);
                        }
                        else
                        {
                            CacheEntry e = new CacheEntry(Value, expiry, _evh);
                            if (_grpInfo != null)
                            {
                                e._grpInfo = (GroupInfo)_grpInfo.Clone();
                            }
                            e._bitset           = (BitSet)_bitset.Clone();
                            e._version          = this._version;
                            e._creationTime     = this._creationTime;
                            e._lastModifiedTime = this._lastModifiedTime;

                            if (this.LockMetaInfo != null)
                            {
                                e.LockExpiration = this.LockExpiration;
                            }

                            e._resyncProviderName  = this._resyncProviderName;
                            e.Priority             = Priority;
                            e._itemRemovedListener = _itemRemovedListener;
                            e._itemUpdateListener  = _itemUpdateListener;                            return(e);
                        }
                    }
                }
            }
            return((CacheEntry)Clone());
        }
Exemplo n.º 4
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="key"></param>
        /// <param name="eh"></param>
        /// <returns></returns>
        internal override bool RemoveInternal(object key, ExpirationHint eh)
        {
            CacheEntry e = null;

            try
            {
                if (ServerMonitor.MonitorActivity)
                {
                    ServerMonitor.LogClientActivity("LocalCache.Remove", "");
                }

                if (_cacheStore == null)
                {
                    throw new InvalidOperationException();
                }

                e = (CacheEntry)_cacheStore.Get(key);
                if (e == null || e.ExpirationHint == null)
                {
                    return(false);
                }
                else
                {
                    e.MarkInUse(NCModulesConstants.LocalCache);

                    if (e.ExpirationHint is AggregateExpirationHint)
                    {
                        AggregateExpirationHint AggHint      = AggregateExpirationHint.Create(Context.StorePoolManager);
                        AggregateExpirationHint entryExpHint = (AggregateExpirationHint)e.ExpirationHint;

                        foreach (ExpirationHint exp in entryExpHint)
                        {
                            if (!exp.Equals(eh))
                            {
                                AggHint.Add(exp);
                            }
                            else
                            {
                                MiscUtil.ReturnExpirationHintToPool(exp, Context.StorePoolManager);
                            }
                        }
                        e.ExpirationHint = AggHint;
                    }
                    else if (e.ExpirationHint.Equals(eh))
                    {
                        MiscUtil.ReturnExpirationHintToPool(e.ExpirationHint, Context.StorePoolManager);
                        e.ExpirationHint = null;
                    }
                }

                // Our store may not be an in memory store
                if (_notifyCacheFull)
                {
                    _notifyCacheFull = false;
                }
                _cacheStore.Insert(key, e, true);
                e.LastModifiedTime = System.DateTime.Now;

                if (_context.PerfStatsColl != null)
                {
                    if (_evictionPolicy != null)
                    {
                        _context.PerfStatsColl.SetEvictionIndexSize((long)_evictionPolicy.IndexInMemorySize);
                    }

                    if (_context.ExpiryMgr != null)
                    {
                        _context.PerfStatsColl.SetExpirationIndexSize((long)_context.ExpiryMgr.IndexInMemorySize);
                    }
                }

                return(true);
            }
            finally
            {
                if (e != null)
                {
                    e.MarkFree(NCModulesConstants.LocalCache);
                }
            }
        }
Exemplo n.º 5
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="key"></param>
        /// <param name="eh"></param>
        /// <returns></returns>
        internal override bool AddInternal(object key, ExpirationHint eh, OperationContext operationContext)
        {
            CacheEntry e = null;

            try
            {
                if (_cacheStore == null)
                {
                    throw new InvalidOperationException();
                }

                e = (CacheEntry)_cacheStore.Get(key);

                if (e == null)
                {
                    return(false);
                }

                //We only allow either idle expiration or Fixed expiration both cannot be set at the same time
                if ((e.ExpirationHint is IdleExpiration && eh is FixedExpiration) ||
                    (e.ExpirationHint is FixedExpiration && eh is IdleExpiration))
                {
                    return(false);
                }

                if (e.ExpirationHint == null)
                {
                    e.ExpirationHint = eh;
                }
                else
                {
                    if (e.ExpirationHint is AggregateExpirationHint)
                    {
                        ((AggregateExpirationHint)e.ExpirationHint).Add(eh);
                    }
                    else
                    {
                        AggregateExpirationHint aeh = AggregateExpirationHint.Create(Context.StorePoolManager);
                        aeh.Add(e.ExpirationHint);
                        aeh.Add(eh);
                        e.ExpirationHint = aeh;
                    }
                }
                e.MarkFree(NCModulesConstants.Global);
                e.MarkInUse(NCModulesConstants.LocalCache);

                //Our store may not be an in memory store

                _cacheStore.Insert(key, e, true);
                e.LastModifiedTime = System.DateTime.Now;

                if (_context.PerfStatsColl != null)
                {
                    if (_evictionPolicy != null)
                    {
                        _context.PerfStatsColl.SetEvictionIndexSize((long)_evictionPolicy.IndexInMemorySize);
                    }

                    if (_context.ExpiryMgr != null)
                    {
                        _context.PerfStatsColl.SetExpirationIndexSize((long)_context.ExpiryMgr.IndexInMemorySize);
                    }
                }
                return(true);
            }
            finally
            {
                if (e != null)
                {
                    e.MarkFree(NCModulesConstants.LocalCache);
                }
            }
        }
Exemplo n.º 6
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="key"></param>
        /// <param name="eh"></param>
        /// <returns></returns>
        internal override bool RemoveInternal(object key, ExpirationHint eh)
        {
            if (ServerMonitor.MonitorActivity)
            {
                ServerMonitor.LogClientActivity("LocalCache.Remove", "");
            }

            if (_cacheStore == null)
            {
                throw new InvalidOperationException();
            }

            CacheEntry e = (CacheEntry)_cacheStore.Get(key);

            if (e == null || e.ExpirationHint == null)
            {
                return(false);
            }
            else
            {
                if (e.ExpirationHint is AggregateExpirationHint)
                {
                    AggregateExpirationHint AggHint      = new AggregateExpirationHint();
                    AggregateExpirationHint entryExpHint = (AggregateExpirationHint)e.ExpirationHint;

                    foreach (ExpirationHint exp in entryExpHint)
                    {
                        if (!exp.Equals(eh))
                        {
                            AggHint.Add(exp);
                        }
                    }
                    e.ExpirationHint = AggHint;
                }
                else if (e.ExpirationHint.Equals(eh))
                {
                    e.ExpirationHint = null;
                }
            }

            if (_notifyCacheFull)
            {
                _notifyCacheFull = false;
            }
            _cacheStore.Insert(key, e, true);
            e.LastModifiedTime = System.DateTime.Now;

            if (_context.PerfStatsColl != null)
            {
                if (_evictionPolicy != null)
                {
                    _context.PerfStatsColl.SetEvictionIndexSize((long)_evictionPolicy.IndexInMemorySize);
                }

                if (_context.ExpiryMgr != null)
                {
                    _context.PerfStatsColl.SetExpirationIndexSize((long)_context.ExpiryMgr.IndexInMemorySize);
                }
            }

            return(true);
        }
Exemplo n.º 7
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="key"></param>
        /// <param name="eh"></param>
        /// <returns></returns>
        internal override bool AddInternal(object key, ExpirationHint eh, OperationContext operationContext)
        {
            if (ServerMonitor.MonitorActivity)
            {
                ServerMonitor.LogClientActivity("LocalCache.Add_2", "");
            }

            if (_cacheStore == null)
            {
                throw new InvalidOperationException();
            }

            CacheEntry e = (CacheEntry)_cacheStore.Get(key);

            if (e == null)
            {
                return(false);
            }

            //We only allow either idle expiration or Fixed expiration both cannot be set at the same time
            if ((e.ExpirationHint is IdleExpiration && eh is FixedExpiration) ||
                (e.ExpirationHint is FixedExpiration && eh is IdleExpiration))
            {
                return(false);
            }

            if (e.ExpirationHint == null)
            {
                e.ExpirationHint = eh;
            }
            else
            {
                if (e.ExpirationHint is AggregateExpirationHint)
                {
                    ((AggregateExpirationHint)e.ExpirationHint).Add(eh);
                }
                else
                {
                    AggregateExpirationHint aeh = new AggregateExpirationHint();
                    aeh.Add(e.ExpirationHint);
                    aeh.Add(eh);
                    e.ExpirationHint = aeh;
                }
            }

            _cacheStore.Insert(key, e, true);
            e.LastModifiedTime = System.DateTime.Now;

            if (_context.PerfStatsColl != null)
            {
                if (_evictionPolicy != null)
                {
                    _context.PerfStatsColl.SetEvictionIndexSize((long)_evictionPolicy.IndexInMemorySize);
                }

                if (_context.ExpiryMgr != null)
                {
                    _context.PerfStatsColl.SetExpirationIndexSize((long)_context.ExpiryMgr.IndexInMemorySize);
                }
            }
            return(true);
        }
Exemplo n.º 8
0
        public static ExpirationHint GetExpirationHintObj(Alachisoft.NCache.Common.Protobuf.Dependency dependency, bool resyncOnExpiration, string serializationContext)
        {
            AggregateExpirationHint hints = new AggregateExpirationHint();

            if (dependency != null && dependency.keyDep != null && dependency.keyDep.Count > 0)
            {
                for (int i = 0; i < dependency.keyDep.Count; i++)
                {
                    Alachisoft.NCache.Caching.AutoExpiration.KeyDependency keyDep =
                        new Alachisoft.NCache.Caching.AutoExpiration.KeyDependency(dependency.keyDep[i].keys.ToArray(),
                                                                                   new DateTime(dependency.keyDep[i].startAfter));

                    hints.Add(keyDep);
                }
            }

            if (dependency != null && dependency.fileDep != null && dependency.fileDep.Count > 0)
            {
                for (int i = 0; i < dependency.fileDep.Count; i++)
                {
                    Alachisoft.NCache.Caching.AutoExpiration.FileDependency fileDep =
                        new Alachisoft.NCache.Caching.AutoExpiration.FileDependency(dependency.fileDep[i].filePaths.ToArray(),
                                                                                    new DateTime(dependency.fileDep[i].startAfter));

                    hints.Add(fileDep);
                }
            }

            if (dependency != null && dependency.oleDbDep != null && dependency.oleDbDep.Count > 0)
            {
                for (int i = 0; i < dependency.oleDbDep.Count; i++)
                {
                    OleDbCacheDependency oleDb = new OleDbCacheDependency(dependency.oleDbDep[i].connectionString,
                                                                          dependency.oleDbDep[i].dbCacheKey);

                    hints.Add(oleDb);
                }
            }



            if (dependency != null && dependency.sql7Dep != null && dependency.sql7Dep.Count > 0)
            {
                for (int i = 0; i < dependency.sql7Dep.Count; i++)
                {
                    Sql7CacheDependency sql7Dep = new Sql7CacheDependency(dependency.sql7Dep[i].connectionString,
                                                                          dependency.sql7Dep[i].dbCacheKey);

                    hints.Add(sql7Dep);
                }
            }


            if (dependency != null && dependency.xtDep != null && dependency.xtDep.Count > 0)
            {
                try
                {
                    for (int i = 0; i < dependency.xtDep.Count; i++)
                    {
                        IFormatter formater = new BinaryFormatter();
                        byte[]     buffer   = dependency.xtDep[i].data;
                        object     obj      = null;

                        using (MemoryStream stream = new MemoryStream(buffer))
                        {
                            obj = formater.Deserialize(stream);
                        }


                        Alachisoft.NCache.Caching.AutoExpiration.ExtensibleDependency xtDep =
                            new Alachisoft.NCache.Caching.AutoExpiration.ExtensibleDependency(
                                (Runtime.Dependencies.ExtensibleDependency)obj);


                        hints.Add(xtDep);
                    }
                }
                catch (SerializationException ex)
                {
                    throw new OperationFailedException(ex.Message);
                }
            }

            if (dependency != null && dependency.oracleDep != null && dependency.oracleDep.Count > 0)
            {
                for (int i = 0; i < dependency.oracleDep.Count; i++)
                {
                    Hashtable parameters = new Hashtable();
                    for (int pc = 0; pc < dependency.oracleDep[i].param.Count; pc++)
                    {
                        OracleCommandParams commandParam = new OracleCommandParams((Runtime.Dependencies.OracleCmdParamsType)dependency.oracleDep[i].param[pc].cmdParam.dbType,
                                                                                   dependency.oracleDep[i].param[pc].cmdParam.value,
                                                                                   (Runtime.Dependencies.OracleParameterDirection)dependency.oracleDep[i].param[pc].cmdParam.direction);
                        parameters.Add(dependency.oracleDep[i].param[pc].key, commandParam);
                    }

                    OracleCacheDependency oraDep = new OracleCacheDependency(dependency.oracleDep[i].connectionString,
                                                                             dependency.oracleDep[i].query,
                                                                             (CommandType)dependency.oracleDep[i].commandType,
                                                                             parameters);

                    hints.Add(oraDep);
                }
            }



            if (dependency != null && dependency.yukonDep != null && dependency.yukonDep.Count > 0)
            {
                for (int i = 0; i < dependency.yukonDep.Count; i++)
                {
                    Hashtable parameters = new Hashtable();
                    for (int pc = 0; pc < dependency.yukonDep[i].param.Count; pc++)
                    {
                        YukonCommandParam yukonParam   = dependency.yukonDep[i].param[pc].cmdParam;
                        SqlCmdParams      commandParam = new SqlCmdParams((SqlDbType)yukonParam.dbType, yukonParam.value);

                        commandParam.CmpInfo                 = (System.Data.SqlTypes.SqlCompareOptions)yukonParam.cmpOptions;
                        commandParam.Direction               = (ParameterDirection)yukonParam.direction;
                        commandParam.IsNullable              = yukonParam.isNullable;
                        commandParam.LocaleID                = yukonParam.localeId;
                        commandParam.Offset                  = yukonParam.offset;
                        commandParam.Precision               = (byte)yukonParam.precision;
                        commandParam.Scale                   = (byte)yukonParam.scale;
                        commandParam.ParamSize               = yukonParam.size;
                        commandParam.SourceColumn            = yukonParam.sourceColumn;
                        commandParam.SourceColumnNullMapping = yukonParam.sourceColumnNull;
                        commandParam.SqlValue                = yukonParam.sqlValue;
                        commandParam.SrcVersion              = (DataRowVersion)yukonParam.version;
                        commandParam.DbType                  = (SqlDbType)yukonParam.typeId;
                        commandParam.TypeName                = yukonParam.typeName;
                        commandParam.UdtName                 = yukonParam.udtTypeName;

                        if (!yukonParam.nullValueProvided)
                        {
                            string val = yukonParam.value as string;
                            if (val != null)
                            {
                                if (commandParam.DbType == SqlDbType.Binary || commandParam.DbType == SqlDbType.VarBinary || commandParam.DbType == SqlDbType.Image || commandParam.DbType == SqlDbType.Timestamp)
                                {
                                    System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding();
                                    commandParam.Value = encoding.GetBytes(val);
                                }
                                else if (commandParam.DbType == SqlDbType.DateTime || commandParam.DbType == SqlDbType.DateTime2 || commandParam.DbType == SqlDbType.Date || commandParam.DbType == SqlDbType.SmallDateTime)
                                {
                                    commandParam.Value = new DateTime(Convert.ToInt64(val));
                                }
                                else if (commandParam.DbType == SqlDbType.Time)
                                {
                                    commandParam.Value = new TimeSpan(Convert.ToInt64(val));
                                }
                                else if (commandParam.DbType == SqlDbType.DateTimeOffset)
                                {
                                    string[] dateOffset = val.Split(new char[] { ',' });
                                    commandParam.Value = new DateTimeOffset(new DateTime(Convert.ToInt64(dateOffset[0])), TimeSpan.FromMinutes(Convert.ToInt32(dateOffset[1])));
                                }
                                else if (commandParam.DbType == SqlDbType.Money || commandParam.DbType == SqlDbType.SmallMoney || commandParam.DbType == SqlDbType.Decimal)
                                {
                                    commandParam.Value = Convert.ToDecimal(val);
                                }
                                else if (commandParam.DbType == SqlDbType.Int)
                                {
                                    commandParam.Value = Convert.ToInt32(val);
                                }
                                else if (commandParam.DbType == SqlDbType.BigInt)
                                {
                                    commandParam.Value = Convert.ToInt64(val);
                                }
                                else if (commandParam.DbType == SqlDbType.SmallInt)
                                {
                                    commandParam.Value = Convert.ToInt16(val);
                                }
                                else if (commandParam.DbType == SqlDbType.Real)
                                {
                                    commandParam.Value = Convert.ToSingle(val);
                                }
                                else if (commandParam.DbType == SqlDbType.UniqueIdentifier)
                                {
                                    commandParam.Value = System.Data.SqlTypes.SqlGuid.Parse(val);
                                }
                                else if (commandParam.DbType == SqlDbType.TinyInt)
                                {
                                    commandParam.Value = Convert.ToByte(val);
                                }
                                else if (commandParam.DbType == SqlDbType.Float)
                                {
                                    commandParam.Value = Convert.ToDouble(val);
                                }
                                else if (commandParam.DbType == SqlDbType.Bit)
                                {
                                    commandParam.Value = Convert.ToBoolean(val);
                                }
                                else
                                {
                                    commandParam.Value = val;
                                }
                            }
                            else
                            {
                                commandParam.Value = DBNull.Value;
                            }
                        }
                        else
                        {
                            commandParam.Value = DBNull.Value;
                        }

                        parameters.Add(dependency.yukonDep[i].param[pc].key, commandParam);
                    }

                    SqlYukonCacheDependency yukonDep = new SqlYukonCacheDependency(dependency.yukonDep[i].connectionString,
                                                                                   dependency.yukonDep[i].query,
                                                                                   (CommandType)dependency.yukonDep[i].commandType,
                                                                                   parameters);

                    hints.Add(yukonDep);
                }
            }
            if (dependency != null && dependency.NosDep != null && dependency.NosDep.Count > 0)
            {
                for (int i = 0; i < dependency.NosDep.Count; i++)
                {
                    Hashtable parameters = new Hashtable();
                    for (int pc = 0; pc < dependency.NosDep[i].param.Count; pc++)
                    {
                        parameters.Add(dependency.NosDep[i].param[pc].key, dependency.NosDep[i].param[pc].value);
                    }
                    NosDBCacheDependency oraDep = new NosDBCacheDependency(dependency.NosDep[i].connectionString,
                                                                           dependency.NosDep[i].query,
                                                                           dependency.NosDep[i].timeout,
                                                                           parameters);

                    hints.Add(oraDep);
                }
            }


            if (resyncOnExpiration)
            {
                hints.SetBit(ExpirationHint.NEEDS_RESYNC);
            }

            IList <ExpirationHint> expHints = hints.Hints;

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

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

            return(hints);
        }