예제 #1
0
        ///  <summary> Insert list of <see cref="CacheItem"/> to the cache </summary>
        /// <param name="keys">The cache keys used to reference the items.</param>
        /// <param name="items">The items that are to be stored</param>
        /// <returns>returns keys that are added or updated successfully and their status.</returns>
        /// <remarks> If CacheItem contains invalid values the related exception is thrown. 
        /// See <see cref="CacheItem"/> for invalid property values and related exceptions</remarks>
        /// <example>The following example demonstrates how to assign an item high priority when you insert 
        /// it into your application's <see cref="Cache"/> object.
        ///	<para><b>Note: </b>For more information about how to use this method with the <see cref="CacheItemRemovedCallback"/> 
        ///	delegate, see <see cref="CacheItemRemovedCallback"/>.
        ///	</para>
        /// First create CacheItems.
        /// <code>
        /// string[] keys = {"SQLDSN", "ORADSN"};
        /// CacheItem items[] = new CacheItem[2];
        /// items[0] = new CacheItem(sqlConnectionString);
        /// item.AbsoluteExpiration = DateTime.Now.AddMinutes(2);
        /// item.SlidingExpiration = TimeSpan.Zero;
        /// item.Priority = CacheItemPriority.High;
        /// item.ItemRemoveCallback = onRemove;
        /// 
        /// items[1] = new CacheItem(oraConnectionString);
        /// item.AbsoluteExpiration = DateTime.Now.AddMinutes(1);
        /// item.SlidingExpiration = TimeSpan.Zero;
        /// item.Priority = CacheItemPriority.Low;
        /// item.ItemRemoveCallback = onRemove;
        /// </code>
        /// 
        /// Then insert CacheItems to the cache
        /// <code>
        ///
        ///	NCache.Cache.Insert(keys, items);
        /// 
        /// </code>
        /// Or simply in a class deriving from <see cref="Alachisoft.NCache.Web.UI.NPage"/> or <see cref="Alachisoft.NCache.Web.UI.NUserControl"/>.
        /// <code>
        /// 
        ///	Cache.Insert(keys, items);
        /// 
        /// </code>
        /// </example>
        public override IDictionary Insert(string[] keys, CacheItem[] items, long[] sizes)
        {

            if (_nCache == null) return null;

            object[] entries = new object[items.Length];

            ExpirationHint hint = null;

            short itemRemovedCallback = -1;
            short itemUpdatedCallback = -1;

            for (int i = 0; i < items.Length; i++)
            {
                string key = keys[i];
                CacheItem item = items[i];

                itemRemovedCallback = -1;
                itemUpdatedCallback = -1;
                if (item.CacheItemRemovedCallback != null)
                {
                    short[] callabackIds = _parent.EventManager.RegisterSelectiveEvent(item.CacheItemRemovedCallback, EventType.ItemRemoved, item.ItemRemovedCallabackDataFilter);
                    itemRemovedCallback = callabackIds[1];
                }
                if (item.CacheItemUpdatedCallback != null)
                {
                    short[] callabackIds = _parent.EventManager.RegisterSelectiveEvent(item.CacheItemUpdatedCallback, EventType.ItemUpdated, item.ItemUpdatedCallabackDataFilter);
                    itemUpdatedCallback = callabackIds[0];
                }

                Hashtable queryInfoDic = item.QueryInfo["query-info"] as Hashtable;
                if (queryInfoDic != null)
                {
                    IDictionaryEnumerator queryInfoEnum = queryInfoDic.GetEnumerator();
                    while (queryInfoEnum.MoveNext())
                    {
                        ArrayList valuesEnum = (ArrayList)queryInfoEnum.Value;
                        for (int j = 0; j < valuesEnum.Count; j++)
                        {
                            if (valuesEnum[j] is DateTime)
                            {
                                valuesEnum[j] = ((DateTime)valuesEnum[j]).Ticks.ToString();
                            }
                        }
                    }
                }

                entries[i] = MakeCompactEntry(key, item.Value,
                    item.AbsoluteExpiration, item.SlidingExpiration, item.Priority,
                    itemRemovedCallback, itemRemovedCallback,  item.QueryInfo, item.FlagMap, null, LockAccessType.IGNORE_LOCK, item.ItemUpdatedCallabackDataFilter, item.ItemRemovedCallabackDataFilter);
            }

            OperationContext operationContext = new OperationContext(OperationContextFieldName.OperationType, OperationContextOperationType.CacheOperation);
            operationContext.Add(OperationContextFieldName.ValueDataSize, sizes);

            return _nCache.InsertEntries(entries, operationContext);
        }
예제 #2
0
 public void Insert(string key, CacheItem item, bool enableRetry)
 {
     _cache.Insert(key, item);
 }           
예제 #3
0
        public void Insert(string key, CacheItem item, LockHandle lockHandle, bool releaseLock, bool enableRetry)
        {

            int retry = _operationRetry;
            do
            {
                try
                {
                    _cache.Insert(key, item, lockHandle, releaseLock);
                    break;
                }
                catch(Exception ex)
                {
                    string message = ex.Message;

                    if (message != null && !(message.ToLower().Contains("connection with server") ||
                        message.ToLower().Contains("no server is available")) || !enableRetry)
                    {
                        throw;
                    }

                    if (retry <= 0)
                        throw ex;

                    retry--;

                    if (_operationRetryDelayInterval > 0)
                        Thread.Sleep(_operationRetryDelayInterval);     
                }
            } while (retry >= 0);

        }
예제 #4
0
파일: Cache.cs 프로젝트: javithalion/NCache
        /// <summary>
        /// Add a <see cref="CacheItem"/> to the cache
        /// </summary>
        /// <param name="key">The cache key used to reference the item.</param>
        /// <param name="item">The item that is to be stored</param>        
        /// <remarks> If CacheItem contains invalid values the related exception is thrown. 
        /// See <see cref="CacheItem"/> for invalid property values and related exceptions</remarks>
        /// <example>The following example demonstrates how to add an item to the cache with an absolute 
        /// expiration of 2 minutes from now, a priority of high, and that notifies the application when the item is removed from the cache.
        /// 
        /// First create a CacheItem.
        /// <code>
        /// object someData = new object();
        /// CacheItem item = new CacheItem(someData);
        /// item.AbsoluteExpiration = DateTime.Now.AddMinutes(2);
        /// item.Priority = CacheItemPriority.High;
        /// item.ItemRemoveCallback = onRemove;
        /// </code>
        /// 
        /// Then add CacheItem to the cache
        /// <code>
        /// 
        /// Cache cache = NCache.InitializeCache("myCache");
        ///	cache.Add("someData", item);
        ///
        /// </code>        
        /// </example>
        public virtual void Add(string key, CacheItem item)
        {
            try
            {
                long size = 0;
                if (item == null)
                    throw new ArgumentNullException("CacheItem");

                AddOperation(key, item.Value, item.AbsoluteExpiration,
                    item.SlidingExpiration,
                    item.Priority, item.CacheItemUpdatedCallback, item.CacheItemRemovedCallback, item.ItemUpdatedCallabackDataFilter, item.ItemRemovedCallabackDataFilter
                    , ref size, true);

            }
            catch (Exception) { if (ExceptionsEnabled) throw; }
        }
예제 #5
0
        internal bool GetKeysDistributionMap(string[] keys, CacheItem[] items,
            ref Dictionary<Address, KeyValuePair<string[], CacheItem[]>> keysDistributionMap)
        {
            bool itemNull = false;
            bool AddNull = false;
            bool pairKey = false;
            bool pairvalue = false;
            bool result = _importHashmap;
            bool itemsAvailable = items != null;
            try
            {
                if (result)
                {
                    Dictionary<Address, Hashtable> keysDistributionList = new Dictionary<Address, Hashtable>();
                    Hashtable keysAndItems = null;
                    string key = String.Empty;
                    CacheItem item = null;

                    for (int i = 0; i < keys.Length; i++)
                    {
                        key = keys[i];
                        if (itemsAvailable)
                            item = items[i];

                        if (item == null)
                            itemNull = true;

                        Address address;
                        lock (_hashmapUpdateMutex)
                        {
                            address = _pool.GetIp(key);

                            if (address == null)
                                AddNull = true;
                        }

                        if (keysDistributionList.ContainsKey(address))
                        {
                            keysAndItems = keysDistributionList[address];
                            keysAndItems[key] = item;
                        }
                        else
                        {
                            keysAndItems = new Hashtable();
                            keysAndItems[key] = item;
                            keysDistributionList[address] = keysAndItems;
                        }
                    }

                    KeyValuePair<string[], CacheItem[]> tmp;
                    Address serverAddress;

                    foreach (KeyValuePair<Address, Hashtable> pair in keysDistributionList)
                    {
                        int index = 0;
                        if (pair.Key == null)
                            pairKey = true;
                        else if (pair.Value == null)
                            pairvalue = true;

                        serverAddress = pair.Key;
                        keysAndItems = pair.Value;

                        string[] distributedKeys = new string[keysAndItems.Count];
                        CacheItem[] distributedItems = null;
                        if (itemsAvailable)
                            distributedItems = new CacheItem[keysAndItems.Count];

                        IDictionaryEnumerator ide = keysAndItems.GetEnumerator();
                        while (ide.MoveNext())
                        {
                            distributedKeys[index] = ide.Key as string;
                            if (itemsAvailable)
                                distributedItems[index] = ide.Value as CacheItem;
                            index++;
                        }

                        tmp = new KeyValuePair<string[], CacheItem[]>(distributedKeys, distributedItems);
                        keysDistributionMap.Add(serverAddress, tmp);
                    }
                }
            }
            catch (Exception e)
            {
                throw new Exception(" Custome exception : value null " + pairvalue + " key null : " + pairKey +
                                    " item null : " + itemNull + "Address null : " + AddNull + " Exception : " +
                                    e.ToString());
            }

            return result;
        }
예제 #6
0
파일: Cache.cs 프로젝트: javithalion/NCache
 /// <summary>
 /// Add a <see cref="CacheItem"/> to the cache
 /// </summary>
 /// <param name="key">The cache key used to reference the item.</param>
 /// <param name="item">The item that is to be stored</param>        
 /// <remarks> If CacheItem contains invalid values the related exception is thrown. 
 /// See <see cref="CacheItem"/> for invalid property values and related exceptions</remarks>		
 /// <example>The following example demonstrates how to add an item to the cache with a sliding expiration of 5 minutes and a priority of 
 /// high, and that notifies the application when the item is removed from the cache.
 /// 
 /// First create a CacheItem.
 /// <code>
 /// CacheItem item = new CacheItem(timeStamp);
 /// item.SlidingExpiration = new TimeSpan(0,5,0);
 /// item.Priority = CacheItemPriority.High;
 /// item.ItemRemoveCallback = onRemove;
 /// </code>
 /// 
 /// Then add CacheItem to the cache
 /// <code>
 /// Cache cache = NCache.InitializeCache("myCache");
 ///	cache.Insert("timestamp", item);
 ///
 /// </code>
 /// </example>
 public virtual void Insert(string key, CacheItem item)
 {
     if (item == null)
         throw new ArgumentNullException("CacheItem");
     long size = 0;
     InsertOperation(key, item.Value,item.AbsoluteExpiration, item.SlidingExpiration,
             item.Priority,
             null,
             LockAccessType.IGNORE_LOCK,
             item.CacheItemUpdatedCallback, item.CacheItemRemovedCallback, item.ItemUpdatedCallabackDataFilter, item.ItemRemovedCallabackDataFilter, ref size, true);
 }
예제 #7
0
파일: Cache.cs 프로젝트: javithalion/NCache
        internal virtual CacheItem GetCacheItemInternal(string key, LockAccessType accessType, TimeSpan lockTimeout, ref LockHandle lockHandle)
        {
            if (_cacheImpl == null) throw new OperationFailedException("Cache is not initialized");

            if (key == null) throw new ArgumentNullException("keys");
            if (key == string.Empty) throw new ArgumentException("key cannot be empty string");
            try
            {
                CacheItem item = new CacheItem();
                Alachisoft.NCache.Caching.CacheEntry entry = null;

                BitSet flagMap = new BitSet();
                object value = _cacheImpl.GetCacheItem(key, flagMap, ref lockHandle, lockTimeout, accessType);

                long objectSize = 0;

                if (value == null) return null;
                if (value is CacheItem)
                {
                    item = (CacheItem)value;
                    if (_perfStatsCollector != null && ((CacheItem)value).Value != null && ((CacheItem)value).Value is byte[])
                        _perfStatsCollector.IncrementAvgItemSize(((byte[])((CacheItem)value).Value).Length);
                    if (DebugAPIConfiguraions.LoggingEnabled)
                        objectSize = ((byte[])item.Value).Length;

                    item.Value = SafeDeserialize(item.Value, _serializationContext, item.FlagMap);
                    if (item.AbsoluteExpiration != Cache.NoAbsoluteExpiration)
                    {
                        item.AbsoluteExpiration = item.AbsoluteExpiration.ToLocalTime();
                    }
                    if (DebugAPIConfiguraions.LoggingEnabled)
                    LogSizeInfo(false, objectSize);

                    return item;
                }

                entry = (Alachisoft.NCache.Caching.CacheEntry)value;
                item.FlagMap = entry.Flag;

                if (entry.Value is CallbackEntry)
                {
                    CallbackEntry cb = (CallbackEntry)entry.Value;
                    if (cb.ItemRemoveCallbackListener != null && cb.ItemRemoveCallbackListener.Count > 0)
                    {
                        foreach (CallbackInfo cbInfo in cb.ItemRemoveCallbackListener)
                        {
                            if (cbInfo.Client == _cacheImpl.ClientID)
                            {
                                item.SetCacheDataNotification((CacheDataNotificationCallback)_callbackIDsMap.GetResource(cbInfo.Callback), EventType.ItemRemoved);
                               break;
                            }
                        }
                    }
                    if (cb.ItemUpdateCallbackListener != null && cb.ItemUpdateCallbackListener.Count > 0)
                    {
                        foreach (CallbackInfo cbInfo in cb.ItemUpdateCallbackListener)
                        {
                            if (cbInfo.Client == _cacheImpl.ClientID)
                            {

                                item.SetCacheDataNotification((CacheDataNotificationCallback)_callbackIDsMap.GetResource(cbInfo.Callback), EventType.ItemUpdated);
                                break;
                            }
                        }
                    }
                    item.Value = cb.Value;
                    if (_perfStatsCollector != null && item.Value != null && item.Value is byte[])
                        _perfStatsCollector.IncrementAvgItemSize(((byte[])item.Value).Length);

                    item.Value = SafeDeserialize(cb.Value, _serializationContext, item.FlagMap);
                }
                else
                {
                    item.Value = entry.Value;
                    if (_perfStatsCollector != null && item.Value != null && item.Value is byte[])
                        _perfStatsCollector.IncrementAvgItemSize(((byte[])item.Value).Length);

                    if (DebugAPIConfiguraions.LoggingEnabled)
                        objectSize = ((byte[])entry.Value).Length;
                    item.Value = SafeDeserialize(entry.Value, _serializationContext, item.FlagMap);
                }
                if (DebugAPIConfiguraions.LoggingEnabled)
                    LogSizeInfo(false, objectSize);
                if (entry != null)
                {
                    item.Priority = (CacheItemPriority)entry.Priority;
                }

                ExpirationHint hint = entry.ExpirationHint;

                DateTime absoluteExpiration = DateTime.MaxValue.ToUniversalTime();
                TimeSpan slidingExpiration = TimeSpan.Zero;

                Alachisoft.NCache.Caching.AutoExpiration.DependencyHelper.GetActualCacheDependency(hint, ref absoluteExpiration, ref slidingExpiration);

                if (absoluteExpiration != Cache.NoAbsoluteExpiration)
                {
                    item.AbsoluteExpiration = absoluteExpiration.ToLocalTime();
                }
                item.SlidingExpiration = slidingExpiration;
                item._creationTime = entry.CreationTime;
                item._lastModifiedTime = entry.LastModifiedTime;
                return item;

            }
            catch (Exception)
            {
                if (ExceptionsEnabled) throw;
            }
            return null;
        }
예제 #8
0
        public override void Insert(string key, CacheItem item, LockHandle lockHandle, bool releaseLock)
        {
            string exceptionMessage = null;
            try
            {
                _webCache.Insert(key, item, lockHandle, releaseLock);
            }
            catch (Exception e)
            {
                exceptionMessage = e.Message;
                throw;
            }
            finally
            {

                try
                {
                    if (_debugConfigurations.IsInLoggingInterval())
                    {
                        APILogItem logItem = new APILogItem(key, item, exceptionMessage);
                        logItem.Signature = "Insert(string key, CacheItem item, LockHandle lockHandle, bool releaseLock)";
                        logItem.RuntimeAPILogItem = (RuntimeAPILogItem)_webCache.APILogHashTable[System.Threading.Thread.CurrentThread.ManagedThreadId];
                        _apiLogger.Log(logItem);
                    }
                }
                catch (Exception)
                { }
                _webCache.APILogHashTable.Remove(System.Threading.Thread.CurrentThread.ManagedThreadId);
            }
        }
예제 #9
0
 public override IDictionary InsertBulk(string[] keys, CacheItem[] items)
 {
     System.Collections.IDictionary iDict = null;
     string exceptionMessage = null;
     try
     {
         iDict = _webCache.InsertBulk(keys, items);
     }
     catch (Exception e)
     {
         exceptionMessage = e.Message;
         throw;
     }
     finally
     {
         try
         {
             if (_debugConfigurations.IsInLoggingInterval())
             {
                 APILogItem logItem = new APILogItem();
                 logItem.Signature = "InsertBulk(string[] keys, CacheItem[] items)";
                 logItem.NoOfKeys = keys.Length;
                 logItem.ExceptionMessage = exceptionMessage;
                 logItem.RuntimeAPILogItem = (RuntimeAPILogItem)_webCache.APILogHashTable[System.Threading.Thread.CurrentThread.ManagedThreadId];
                 _apiLogger.Log(logItem);
             }
         }
         catch (Exception)
         { }
         _webCache.APILogHashTable.Remove(System.Threading.Thread.CurrentThread.ManagedThreadId);
     }
     return iDict;
 }
예제 #10
0
        private MutateOpResult UpdateIfNumeric(string key, CacheItem cacheItem, ulong value, UpdateType updateType)
        {
            MutateOpResult returnObject = new MutateOpResult();
            MemcachedItem memCachedItem = (MemcachedItem)cacheItem.Value;
            if (memCachedItem != null)
            {
                ObjectArrayData objectDataArray = GetObjectArrayData(memCachedItem.Data);

                string tempObjectString = "";
                try
                {
                    tempObjectString = Encoding.ASCII.GetString(objectDataArray.dataBytes);
                }
                catch (Exception e)
                {
                    ThrowCacheRuntimeException(e);
                }

                if (IsUnsignedNumeric(tempObjectString))
                {
                    ulong originalValue = Convert.ToUInt64(tempObjectString);
                    ulong finalValue;

                    if (updateType == UpdateType.Increment)
                    {
                        finalValue = originalValue + value;
                    }
                    else
                    {
                        if (value > originalValue)
                            finalValue = 0;
                        else
                            finalValue = originalValue - value;
                    }

                    try
                    {

                        MemcachedItem memCacheItem = new MemcachedItem();
                        memCacheItem.Data = CreateObjectArray(objectDataArray.flags, Encoding.ASCII.GetBytes(finalValue + ""));


                        ulong getVersion = GetLatestVersion();

                        memCacheItem.InternalVersion = getVersion;

                        cacheItem.Value = memCacheItem;

                        _cache.Insert(key, cacheItem);

                        returnObject.ReturnResult = Result.SUCCESS;
                        returnObject.Value = getVersion;
                        returnObject.MutateResult = finalValue;
                    }
                    catch (Exception e)
                    {
                        ThrowCacheRuntimeException(e);
                    }
                }
                else
                {
                    returnObject.ReturnResult = Result.ITEM_TYPE_MISMATCHED;
                    returnObject.Value = null;
                    returnObject.MutateResult = 0;
                }
            }
            return returnObject;
        }
예제 #11
0
 internal override IDictionary InsertBulkOperation(string[] keys, CacheItem[] items, ref long[] sizes, bool allowQueryTags)
 {
     return _webCache.InsertBulkOperation(keys, items, ref sizes, true);
 }
예제 #12
0
        private OperationResult JoinObjects(string key, CacheItem cacheItem, object objectToJoin, UpdateType updateType)
        {
            OperationResult returnObject = new OperationResult();
            ObjectArrayData objectDataArray = GetObjectArrayData(((MemcachedItem)cacheItem.Value).Data);
            byte[] originalByteObject = objectDataArray.dataBytes;
            byte[] byteObjectToJoin = (byte[])objectToJoin;

            byte[] joinedObject = new byte[originalByteObject.Length + byteObjectToJoin.Length];

            if (updateType == UpdateType.Append)
            {
                System.Buffer.BlockCopy(originalByteObject, 0, joinedObject, 0, originalByteObject.Length);
                System.Buffer.BlockCopy(byteObjectToJoin, 0, joinedObject, originalByteObject.Length, byteObjectToJoin.Length);
            }
            else
            {
                System.Buffer.BlockCopy(byteObjectToJoin, 0, joinedObject, 0, byteObjectToJoin.Length);
                System.Buffer.BlockCopy(originalByteObject, 0, joinedObject, byteObjectToJoin.Length, originalByteObject.Length);
            }

            try
            {
                
                MemcachedItem memCacheItem = new MemcachedItem();
                memCacheItem.Data = CreateObjectArray(objectDataArray.flags, joinedObject);
                
                ulong getVersion = GetLatestVersion();
               
                memCacheItem.InternalVersion = getVersion;
                
                cacheItem.Value = memCacheItem;
                
                _cache.Insert(key, cacheItem);
                
                returnObject = CreateReturnObject(Result.SUCCESS, getVersion);
            }
            catch (Exception e)
            {
                ThrowCacheRuntimeException(e);
            }

            return returnObject;
        }
예제 #13
0
 private GetOpResult CreateGetObject(string key, CacheItem cacheItem)
 {
    
     GetOpResult getObject = new GetOpResult();
     MemcachedItem memCacheItem = (MemcachedItem)cacheItem.Value;
     ObjectArrayData objectArrayData = GetObjectArrayData(memCacheItem.Data);
     getObject.Key = key;
     getObject.Flag = objectArrayData.flags;
     getObject.Value = objectArrayData.dataBytes;
     getObject.Version = memCacheItem.InternalVersion;
     getObject.ReturnResult = Result.SUCCESS;
     return getObject;
 }
예제 #14
0
     //whenever the item is updated, the version is incremented by 1
     private CacheItem CreateCacheItem(uint flags, object dataBlock, long expirationTimeInSeconds, ulong version)
     {
         MemcachedItem memCacheItem = new MemcachedItem();
         memCacheItem.Data = CreateObjectArray(flags, dataBlock);
         memCacheItem.InternalVersion = version;
         CacheItem cacheItem = new CacheItem(memCacheItem);
 ;
         if (expirationTimeInSeconds != 0)
             cacheItem.AbsoluteExpiration = CreateExpirationDate(expirationTimeInSeconds);
         return cacheItem;
     }
예제 #15
0
        ///  <summary> Insert list of <see cref="CacheItem"/> to the cache </summary>
        /// <param name="keys">The cache keys used to reference the items.</param>
        /// <param name="items">The items that are to be stored</param>
        /// <returns>returns keys that are added or updated successfully and their status.</returns>
        /// <remarks> If CacheItem contains invalid values the related exception is thrown. 
        /// See <see cref="CacheItem"/> for invalid property values and related exceptions</remarks>
        /// <example>The following example demonstrates how to assign an item high priority when you insert 
        /// it into your application's <see cref="Cache"/> object.
        ///	<para><b>Note: </b>For more information about how to use this method with the <see cref="CacheItemRemovedCallback"/> 
        ///	delegate, see <see cref="CacheItemRemovedCallback"/>.
        ///	</para>
        /// First create CacheItems.
        /// <code>
        /// string[] keys = {"SQLDSN", "ORADSN"};
        /// CacheItem items[] = new CacheItem[2];
        /// items[0] = new CacheItem(sqlConnectionString);
        /// item.AbsoluteExpiration = DateTime.Now.AddMinutes(2);
        /// item.SlidingExpiration = TimeSpan.Zero;
        /// item.Priority = CacheItemPriority.High;
        /// item.ItemRemoveCallback = onRemove;
        /// 
        /// items[1] = new CacheItem(oraConnectionString);
        /// item.AbsoluteExpiration = DateTime.Now.AddMinutes(1);
        /// item.SlidingExpiration = TimeSpan.Zero;
        /// item.Priority = CacheItemPriority.Low;
        /// item.ItemRemoveCallback = onRemove;
        /// </code>
        /// 
        /// Then insert CacheItems to the cache
        /// <code>
        ///
        ///	NCache.Cache.Insert(keys, items);
        /// 
        /// </code>
        /// Or simply in a class deriving from <see cref="Alachisoft.NCache.Web.UI.NPage"/> or <see cref="Alachisoft.NCache.Web.UI.NUserControl"/>.
        /// <code>
        /// 
        ///	Cache.Insert(keys, items);
        /// 
        /// </code>
        /// </example>
        public override IDictionary Insert(string[] keys, CacheItem[] items, long[] sizes)
        {
            Dictionary<Address, KeyValuePair<string[], CacheItem[]>> keysDistributionMap = new Dictionary<Address, KeyValuePair<string[], CacheItem[]>>();
            Request request;
            if (_broker.ImportHashmap)
            {
                if (!_broker.PoolFullyConnected)
                {
                    BulkInsertCommand command = new BulkInsertCommand(keys, items, _parent, CacheId);
                    request = _broker.CreateDedicatedRequest(command);
                }
                else
                {
                    request = new Request(true, _broker.OperationTimeOut);
                    _broker.GetKeysDistributionMap(keys, items, ref keysDistributionMap);
                    foreach (Address serverAddress in keysDistributionMap.Keys)
                    {
                        KeyValuePair<string[], CacheItem[]> keysAndItems = keysDistributionMap[serverAddress];
                        BulkInsertCommand command = new BulkInsertCommand(keysAndItems.Key, keysAndItems.Value, _parent, CacheId);
                        command.ClientLastViewId = _broker.ClientLastViewId;
                        request.AddCommand(serverAddress, command);
                    }
                }
            }
            else
            {
                BulkInsertCommand command = new BulkInsertCommand(keys, items, _parent, CacheId);
                request = _broker.CreateRequest(command);
            }

            _broker.ExecuteRequest(request);

            CommandResponse res = request.Response;
            res.ParseResponse();

            return res.KeyValueDic;
        }
예제 #16
0
        CacheItem CreateCacheItem(object value, Expiration expiration)
        {
            DateTime absolute = Cache.NoAbsoluteExpiration;
            TimeSpan sliding = Cache.NoSlidingExpiration;

            if (expiration != null)
            {
                switch (expiration.ExpirationType)
                {
                    case ExpirationType.Absolute:
                        absolute = DateTime.Now.AddMinutes(expiration.Duration);
                        break;

                    case ExpirationType.Sliding:
                        sliding = TimeSpan.FromMinutes(expiration.Duration);
                        break;
                }
            }

            CacheItem item = new CacheItem(value);
            item.AbsoluteExpiration = absolute;
            item.SlidingExpiration = sliding;
            return item;
        }
예제 #17
0
        /// <summary>
        /// Creates a shallow copy of CacheItem
        /// </summary>
        /// <returns></returns>
        public object Clone()
        {
            CacheItem newItem = new CacheItem();

            newItem._abs = this._abs;
            newItem._sld = this._sld;
            newItem.FlagMap = this.FlagMap;
            newItem._p = this._p;
            newItem._queryInfo = this._queryInfo;
            newItem._v = this._v;
            newItem._cacheItemUpdateCallback = _cacheItemUpdateCallback;
            newItem._cacheItemRemovedCallback = this._cacheItemRemovedCallback;
            newItem._itemUpdatedDataFilter = this._itemUpdatedDataFilter;
            newItem._itemRemovedDataFilter = this._itemRemovedDataFilter;
            return newItem;
        }
예제 #18
0
		private static bool LoadCache()
		{
			try
			{
                if (InitializeCache())
                {
                    Console.WriteLine("Loading products into " + _cache.ToString() + "...");

                    Hashtable keyVals = _db.LoadProducts();

                    String[] keys = new String[keyVals.Keys.Count];
                    CacheItem[] items = new CacheItem[keyVals.Keys.Count];

                    IDictionaryEnumerator ide = keyVals.GetEnumerator();
                    int i = 0;
                    while (ide.MoveNext())
                    {
                        keys[i] = ide.Key.ToString();
                        items[i++] = new CacheItem(ide.Value);
                    }

                    _cache.AddBulk(keys, items);
                }
                else
                    return false;
			}
			catch(Exception ex)
			{
				Console.WriteLine("Exception : " + ex.Message);
				return false;
			}
			return true;
		}
예제 #19
0
파일: Cache.cs 프로젝트: javithalion/NCache
        /// <summary>
        /// Inserts a <see cref="CacheItem"/> to the cache if not already existing.
        /// Otherwise updates an existing item if it not already locked or if the correct lock-id is specified.
        /// </summary>
        /// <param name="key">The cache key used to reference the item.</param>
        /// <param name="item">The item that is to be stored</param>
        /// <param name="lockHandle">An instance of <see cref="LockHandle"/>. If the item is locked, then it can be updated only if the correct lockHandle is specified.</param>
        /// <param name="releaseLock">A flag to determine whether or not release lock after operation is performed.</param>        
        /// <remarks>If lockId does not match with the lockId associated with cached item,
        /// an exception will be thrown.</remarks>		
        /// <example>The following example demonstrates how to update a locked item in the cache.
        /// 
        /// First create a CacheItem.
        /// <code>
        /// Cache theCache = NCache.InitializeCache("myreplicatedcache");
        /// </code>
        /// Add an item int the cache.
        /// <code>
        /// theCache.Add("cachedItemKey", new CacheItem("cachedItemValue"));
        /// </code>
        /// Create the objects for lockid and lockdate.
        /// <code>
        /// LockHandle lockHandle = new LockHandle();
        /// </code>    
        /// Get the added item from cache and acquire a lock.
        /// <code>
        /// object cachedItem = theCache.Get("cachedItemKey", Cache.NoLockingExpiration, ref lockHandle, true);
        /// if (cachedItem != null)
        /// {
        ///     try
        ///     {
        ///         theCache.Insert("cachedItemKey", new CacheItem("someothervalue"), lockHandle, true);
        ///         string cachedValue = (string)theCache.Get("cachedItemKey");
        ///     }
        ///     catch (OperationFailedException ex)
        ///     {
        ///         //Do something
        ///     }
        /// }
        /// </code>
        /// </example>
        public virtual void Insert(string key, CacheItem item, LockHandle lockHandle, bool releaseLock)
        {
            if (item == null)
                throw new ArgumentNullException("CacheItem");

            LockAccessType accessType = releaseLock ? LockAccessType.RELEASE : LockAccessType.DONT_RELEASE;
            long size = 0;
            InsertOperation(key, item.Value,
                   item.AbsoluteExpiration, item.SlidingExpiration,

                    item.Priority,
                    lockHandle,
                    accessType,
                    item.CacheItemUpdatedCallback,
                    item.CacheItemRemovedCallback,
                    item.ItemUpdatedCallabackDataFilter,
                    item.ItemRemovedCallabackDataFilter, ref size, true);
        }
예제 #20
0
        public BulkInsertCommand(string[] keys, CacheItem[] items,  Cache parent, string cacheId)
        {
            base.name = "BulkInsertCommand";
            _parent = parent;
            base.BulkKeys = keys;
            _bulkInsertCommand = new Alachisoft.NCache.Common.Protobuf.BulkInsertCommand();
            _bulkInsertCommand.requestId = base.RequestId;

            for (int i = 0; i < keys.Length; i++)
            {
                CacheItem item = items[i];

                _insertCommand = new Alachisoft.NCache.Common.Protobuf.InsertCommand();
                _insertCommand.key = keys[i];

                Alachisoft.NCache.Caching.UserBinaryObject ubObject = Alachisoft.NCache.Caching.UserBinaryObject.CreateUserBinaryObject((byte[])item.Value);
                _insertCommand.data.AddRange(ubObject.DataList);

                if (item.AbsoluteExpiration != Cache.NoAbsoluteExpiration)
                    _insertCommand.absExpiration = item.AbsoluteExpiration.Ticks;

                if (item.SlidingExpiration != Cache.NoSlidingExpiration)
                    _insertCommand.sldExpiration = item.SlidingExpiration.Ticks;

                _insertCommand.flag = item.FlagMap.Data;
               _insertCommand.priority = (int)item.Priority;

                // Updated in Version 4.2 [Dated 20-Nov-2013; Author: Sami]
                ObjectQueryInfo objectQueryInfo = new ObjectQueryInfo();

                if (item.QueryInfo["query-info"] != null)
                    objectQueryInfo.queryInfo = ProtobufHelper.GetQueryInfoObj(item.QueryInfo["query-info"] as Hashtable);

                _insertCommand.objectQueryInfo = objectQueryInfo;

                short removeCallbackId = -1;
                short updateCallbackId = -1;
                EventDataFilter itemUpdateDataFilter = EventDataFilter.None;
                EventDataFilter itemRemovedDataFilter = EventDataFilter.None;

                if (item.CacheItemRemovedCallback != null)
                {
                    itemRemovedDataFilter = item.ItemRemovedCallabackDataFilter;
                    short[] callabackIds = _parent.EventManager.RegisterSelectiveEvent(item.CacheItemRemovedCallback, EventType.ItemRemoved, itemRemovedDataFilter);
                    removeCallbackId = callabackIds[1];
                }

                if (item.CacheItemUpdatedCallback != null)
                {
                    itemUpdateDataFilter = item.ItemUpdatedCallabackDataFilter;
                    short[] callabackIds = _parent.EventManager.RegisterSelectiveEvent(item.CacheItemUpdatedCallback, EventType.ItemUpdated, itemUpdateDataFilter);
                    updateCallbackId = callabackIds[0];
                }

                _insertCommand.removeCallbackId = removeCallbackId;
                _insertCommand.updateCallbackId = updateCallbackId;
                _insertCommand.updateDataFilter = (short)itemUpdateDataFilter;
                _insertCommand.removeDataFilter = (short)itemRemovedDataFilter;

                _bulkInsertCommand.insertCommand.Add(_insertCommand);
            }
        }
예제 #21
0
파일: Cache.cs 프로젝트: javithalion/NCache
        ///  <summary> Insert list of <see cref="CacheItem"/> to the cache </summary>
        /// <param name="keys">The cache keys used to reference the items.</param>
        /// <param name="items">The items that are to be stored</param>
        /// <param name="sizes"></param>
        /// <param name="allowQueryTags"></param>
        /// <returns>returns keys that are added or updated successfully and their status.</returns>
        ///  <remarks> If CacheItem contains invalid values the related exception is thrown. 
        ///  See <see cref="CacheItem"/> for invalid property values and related exceptions</remarks>
        ///  <example>The following example demonstrates how to assign an item high priority when you insert 
        ///  it into your application's <see cref="Cache"/> object.
        /// 	<para><b>Note: </b>For more information about how to use this method with the <see cref="CacheItemRemovedCallback"/> 
        /// 	delegate, see <see cref="CacheItemRemovedCallback"/>.
        /// 	</para>
        ///  First create CacheItems.
        ///  <code>
        ///  string[] keys = {"SQLDSN", "ORADSN"};
        ///  CacheItem items[] = new CacheItem[2];
        ///  items[0] = new CacheItem(sqlConnectionString);
        ///  item.AbsoluteExpiration = DateTime.Now.AddMinutes(2);
        ///  item.Priority = CacheItemPriority.High;
        ///  item.ItemRemoveCallback = onRemove;
        ///  
        ///  items[1] = new CacheItem(oraConnectionString);
        ///  item.AbsoluteExpiration = DateTime.Now.AddMinutes(1);
        ///  item.Priority = CacheItemPriority.Low;
        ///  item.ItemRemoveCallback = onRemove;
        ///  </code>
        ///  
        ///  Then insert CacheItems to the cache
        ///  <code>
        ///  Cache cache = NCache.InitializeCache("myCache");
        ///  string[] keys = new string[] { "myItem1", "myItem2" };
        ///  CacheItem[] items = new CacheItem[]{myItem1, myItem2};
        /// 	cache.Insert(keys, items, "Connection", null);
        ///  
        ///  </code>
        ///  </example>        
        internal virtual IDictionary InsertBulkOperation(string[] keys, CacheItem[] items, ref long[] sizes, bool allowQueryTags)
        {
            if (_cacheImpl == null) throw new OperationFailedException("Cache is not initialized");

            if (keys == null) throw new ArgumentNullException("keys");
            if (items == null) throw new ArgumentNullException("items");
            if (keys.Length != items.Length) throw new ArgumentException("keys count is not equals to items count");
            if (keys.Length == 0) throw new ArgumentException("There is no key present in keys array");
            if (IsNullOrDupliate(keys)) throw new ArgumentException("Duplicate keys found in provided 'key' array.");
            CacheItem[] clonedItems = new CacheItem[items.Length];

            int noOfObjects = 0;
            long sumObjectSize = 0;

            if (DebugAPIConfiguraions.LoggingEnabled)
                noOfObjects = items.Length;

            for (int i = 0; i < items.Length; i++)
            {
                string key = keys[i];
                BitSet flagMap = new BitSet();
                if (items[i] == null)
                    throw new Exception("CacheItem cannot be null");

                CacheItem cloned = items[i].Clone() as CacheItem;

                long size = 0;
                if (sizes[i] > 0)
                    size = sizes[i];

                ValidateKeyValue(key, cloned.Value);

                Hashtable queryInfo = new Hashtable();
                if (allowQueryTags)
                {
                    queryInfo["query-info"] = GetQueryInfo(cloned.Value);
                }
                cloned.QueryInfo = queryInfo;

                cloned.Value = SafeSerialize(cloned.Value, _serializationContext, ref flagMap, ref size);
                sizes[i] = size;

                if (DebugAPIConfiguraions.LoggingEnabled)
                    sumObjectSize += cloned.Value is byte[] ? ((byte[])cloned.Value).Length : 0;

                if (_perfStatsCollector != null)
                {
                    if (cloned.Value != null) _perfStatsCollector.IncrementAvgItemSize(((byte[])cloned.Value).Length);
                }

                cloned.FlagMap = flagMap;

                cloned.AbsoluteExpiration = ToUTC(cloned.AbsoluteExpiration);

                clonedItems[i] = cloned;
            }

            if (DebugAPIConfiguraions.LoggingEnabled)
                LogSizeInfo(true, sumObjectSize, noOfObjects);

            short dsItemAddedCallbackID = -1;

            try
            {
                return _cacheImpl.Insert(keys, clonedItems, sizes);
            }
            catch (Exception)
            {
                if (ExceptionsEnabled) throw;
                return null;
            }
        }
예제 #22
0
 /// <summary>
 /// Insert information in cache, along with the expirations and callback.
 /// </summary>
 /// <param name="id">Session ID</param>
 /// <param name="table">Value needed to be stored</param>
 /// 
 private void PutInNCache(string id, Hashtable table, object lockID, bool enableRetry)
 {
     byte[] buffer = null;
     using (MemoryStream stream = new MemoryStream())
     {
         BinaryFormatter formatter = new BinaryFormatter();
         formatter.Serialize(stream, table);
         buffer = stream.ToArray();
         stream.Close();
     }
     CacheItem sessionItem = new CacheItem(buffer);
     sessionItem.Priority = CacheItemPriority.NotRemovable;
     sessionItem.SlidingExpiration = new TimeSpan(0, (int)table[TIMEOUT_KEY], 0);
     lock (s_dataLock)
     {
         if (s_cacheNeedInit) InitializeCache();
     }
     if (_lockSessions)
     {
         _cache.Insert(GetUniqueSessionId(id), sessionItem, lockID as LockHandle, true, enableRetry);
     }
     else
         _cache.Insert(GetUniqueSessionId(id), sessionItem, enableRetry);
     _cache.CurrentSessionCache = null;
 }
예제 #23
0
파일: Cache.cs 프로젝트: javithalion/NCache
 ///  <summary>
 ///  Add array of <see cref="CacheItem"/> to the cache.
 ///  </summary>
 /// <param name="keys">The cache keys used to reference the items.</param>
 /// <param name="items">The items that are to be stored</param>
 /// <returns>keys that are added or that alredy exists in the cache and their status.</returns>
 ///  <remarks> If CacheItem contains invalid values the related exception is thrown. 
 ///  See <see cref="CacheItem"/> for invalid property values and related exceptions</remarks>		
 ///  <example>The following example demonstrates how to add items to the cache with an absolute 
 ///  expiration 2 minutes from now, a priority of 
 ///  high, and that notifies the application when the item is removed from the cache.
 ///  
 ///  First create a CacheItems.
 ///  <code>
 ///  string keys = {"First", "Second"};
 ///  CacheItem items = new CacheItem[2]
 ///  items[0] = new CacheItem(firstTimeStamp);
 ///  items[0].AbsoluteExpiration = DateTime.Now.AddMinutes(2);
 ///  items[0].Priority = CacheItemPriority.High;
 ///  items[0].ItemRemoveCallback = onRemove;
 /// 
 ///  items[1] = new CacheItem(secondTimeStamp);
 ///  items[1].AbsoluteExpiration = DateTime.Now.AddMinutes(2);
 ///  items[1].Priority = CacheItemPriority.Low;
 ///  items[1].ItemRemoveCallback = onRemove;
 ///  </code>
 ///  
 ///  Then add CacheItem to the cache
 ///  <code>
 ///  
 ///  Cache cache = NCache.InitializeCache("myCache");
 /// 	cache.Add(keys, items);
 /// 
 ///  </code>        
 ///  </example>
 public virtual IDictionary AddBulk(string[] keys, CacheItem[] items)
 {
     long[] sizes = new long[items.Length];
     return AddBulkOperation(keys, items, ref sizes, true);
 }
예제 #24
0
 public virtual IDictionary Insert(string[] keys, CacheItem[] items, long[] sizes)
 {
     return null;
 }