public static OperationResult Set(string key, object value, uint flags) { StoreObject obj = new StoreObject(); obj.Flags = flags; obj.Value = value; lock (_ht) { _ht[key] = obj; } OperationResult result = new OperationResult(); result.ReturnResult = Result.SUCCESS; ulong cas=1; result.Value = cas; return result; }
public OperationResult Add(string key, uint flags, long expirationTimeInSeconds, object dataBlock) { if (string.IsNullOrEmpty(key) || dataBlock == null) ThrowInvalidArgumentsException(); OperationResult returnObject = new OperationResult(); try { returnObject = AddItemSuccessfully(key, flags, expirationTimeInSeconds, dataBlock); } catch (Exception e) { ThrowCacheRuntimeException(e); } return returnObject; }
public OperationResult InitCache(string cacheID) { if (string.IsNullOrEmpty(cacheID)) ThrowInvalidArgumentsException(); OperationResult returnObject = new OperationResult(); try { _cache = Alachisoft.NCache.Web.Caching.NCache.InitializeCache(cacheID); if (!_cache.Contains(ItemVersionKey)) { _cache.Add(ItemVersionKey, ItemVersionValue); } returnObject = CreateReturnObject(Result.SUCCESS, null); } catch (Exception e) { ThrowCacheRuntimeException(e); } return returnObject; }
//Private common store method. private string store(string command, string key, bool keyIsChecked, object value, uint hash, int expiry, ulong unique) { if (!keyIsChecked) { checkKey(key); } SerializedType type; byte[] bytes; try { bytes = Serializer.Serialize(value, out type, CompressionThreshold); } catch (Exception e) { //If serialization fails, return false; logger.Error("Error serializing object for key '" + key + "'.", e); return ""; } string commandResult = ""; if (memcachedProvider == null) { ConnectionError(); return ""; } OperationResult opResult = new OperationResult(); try { switch (command) { case "set": opResult = memcachedProvider.Set(key, (ushort)type, expiry, bytes); break; case "add": opResult = memcachedProvider.Add(key, (ushort)type, expiry, bytes); break; case "replace": opResult = memcachedProvider.Replace(key, (ushort)type, expiry, bytes); break; case "append": opResult = memcachedProvider.Append(key, bytes, unique); break; case "prepend": opResult = memcachedProvider.Prepend(key, bytes, unique); break; case "cas": opResult = memcachedProvider.CheckAndSet(key, (ushort)type, expiry, unique, bytes); break; } if (command.Equals("replace") && opResult.ReturnResult == Result.ITEM_NOT_FOUND) commandResult = "NOT_STORED"; else switch (opResult.ReturnResult) { case Result.SUCCESS: commandResult = "STORED"; break; case Result.ITEM_EXISTS: commandResult = "NOT_STORED"; break; case Result.ITEM_NOT_FOUND: commandResult = "NOT_FOUND"; break; case Result.ITEM_MODIFIED: commandResult = "EXISTS"; break; } } catch (InvalidArgumentsException e) { commandResult = "CLIENT_ERROR bad command line format"; } catch (CacheRuntimeException e) { commandResult = "SERVER_ERROR"; } return commandResult; }
/// <summary> /// Stores data to cache. /// /// If data does not already exist for this key on the server, or if the key is being /// deleted, the specified value will not be stored. /// The server will automatically delete the value when the expiration time has been reached. /// /// If compression is enabled, and the data is longer than the compression threshold /// the data will be stored in compressed form. /// /// As of the current release, all objects stored will use .NET serialization. /// </summary> /// <param name="cmdname">action to take (set, add, replace)</param> /// <param name="key">key to store cache under</param> /// <param name="value">object to cache</param> /// <param name="expiry">expiration</param> /// <param name="hashCode">if not null, then the int hashcode to use</param> /// <param name="asString">store this object as a string?</param> /// <returns>true/false indicating success</returns> private bool Set(string cmdname, string key, object obj, DateTime expiry, object hashCode, bool asString) { if(expiry < DateTime.Now) return true; if(cmdname == null || cmdname.Trim().Length == 0 || key == null || key.Length == 0) { if(log.IsErrorEnabled) { log.Error(GetLocalizedString("set key null")); } return false; } if (memcachedProvider == null) { if (log.IsErrorEnabled) { log.Error(GetLocalizedString("failed to get socket").Replace("$$Host$$","localhost")); } return false; } if (expiry == DateTime.MaxValue) expiry = new DateTime(0); // store flags int flags = 0; // byte array to hold data byte[] val; int length = 0; // useful for sharing data between .NET and non-.NET // and also for storing ints for the increment method if(NativeHandler.IsHandled(obj)) { if(asString) { if(obj != null) { if(log.IsInfoEnabled) { log.Info(GetLocalizedString("set store data as string").Replace("$$Key$$", key).Replace("$$Class$$", obj.GetType().Name)); } try { val = UTF8Encoding.UTF8.GetBytes(obj.ToString()); } catch(ArgumentException ex) { if(log.IsErrorEnabled) { log.Error(GetLocalizedString("set invalid encoding").Replace("$$Encoding$$", _defaultEncoding), ex); } return false; } } else { val = new byte[0]; length = 0; } } else { if(log.IsInfoEnabled) { log.Info(GetLocalizedString("set store with native handler")); } try { val = NativeHandler.Encode(obj); length = val.Length; } catch(ArgumentException e) { if(log.IsErrorEnabled) { log.Error(GetLocalizedString("set failed to native handle object"), e); } return false; } } } else { if(obj != null) { if(log.IsInfoEnabled) { log.Info(GetLocalizedString("set serializing".Replace("$$Key$$", key).Replace("$$Class$$", obj.GetType().Name))); } // always serialize for non-primitive types try { MemoryStream memStream = new MemoryStream(); new BinaryFormatter().Serialize(memStream, obj); val = memStream.GetBuffer(); length = (int) memStream.Length; flags |= F_SERIALIZED; } catch(IOException e) { // if we fail to serialize, then // we bail if(log.IsErrorEnabled) { log.Error(GetLocalizedString("set failed to serialize").Replace("$$Object$$", obj.ToString()), e); } return false; } } else { val = new byte[0]; length = 0; } } // now try to compress if we want to // and if the length is over the threshold if(_compressEnable && length > _compressThreshold) { if(log.IsInfoEnabled) { log.Info(GetLocalizedString("set trying to compress data")); log.Info(GetLocalizedString("set size prior").Replace("$$Size$$", length.ToString(new NumberFormatInfo()))); } try { MemoryStream memoryStream = new MemoryStream(); GZipOutputStream gos = new GZipOutputStream(memoryStream); gos.Write(val, 0, length); gos.Finish(); // store it and set compression flag val = memoryStream.GetBuffer(); length = (int)memoryStream.Length; flags |= F_COMPRESSED; if(log.IsInfoEnabled) { log.Info(GetLocalizedString("set compression success").Replace("$$Size$$", length.ToString(new NumberFormatInfo()))); } } catch(IOException e) { if(log.IsErrorEnabled) { log.Error(GetLocalizedString("set compression failure"), e); } } } // now write the data to the cache server try { OperationResult opResult = new OperationResult(); switch (cmdname) { case "set": opResult = memcachedProvider.Set(key, (uint)flags, GetExpirationTime(expiry), val); break; case "add": opResult = memcachedProvider.Add(key, (uint)flags, GetExpirationTime(expiry), val); break; case "replace": opResult = memcachedProvider.Replace(key, (uint)flags, GetExpirationTime(expiry), val); break; } string line = ""; if (cmdname.Equals("replace") && opResult.ReturnResult == Result.ITEM_NOT_FOUND) line = "NOT_STORED"; else switch (opResult.ReturnResult) { case Result.SUCCESS: line = "STORED"; break; case Result.ITEM_EXISTS: line = "NOT_STORED"; break; case Result.ITEM_NOT_FOUND: line = "NOT_FOUND"; break; case Result.ITEM_MODIFIED: line = "EXISTS"; break; } string cmd = cmdname + " " + key + " " + flags + " " + GetExpirationTime(expiry) + " " + length + "\r\n"; if(log.IsInfoEnabled) { log.Info(GetLocalizedString("set memcached command result").Replace("$$Cmd$$", cmd).Replace("$$Line$$", line)); } if(STORED == line) { if(log.IsInfoEnabled) { log.Info(GetLocalizedString("set success").Replace("$$Key$$", key)); } return true; } else if(NOTSTORED == line) { if(log.IsInfoEnabled) { log.Info(GetLocalizedString("set not stored").Replace("$$Key$$", key)); } } else { if(log.IsErrorEnabled) { log.Error(GetLocalizedString("set error").Replace("$$Key$$", key).Replace("$$Size$$", length.ToString(new NumberFormatInfo())).Replace("$$Line$$", line)); } } } catch(Exception e) { // exception thrown if(log.IsErrorEnabled) { log.Error(GetLocalizedString("set IOException"), e); } } return false; }
public OperationResult Replace(string key, uint flags, long expirationTimeInSeconds, object dataBlock) { if (string.IsNullOrEmpty(key) || dataBlock == null) ThrowInvalidArgumentsException(); OperationResult returnObject = new OperationResult(); try { if (_cache.Contains(key)) returnObject = InsertItemSuccessfully(key, flags, expirationTimeInSeconds, dataBlock); else returnObject = CreateReturnObject(Result.ITEM_NOT_FOUND, null); } catch (Exception e) { ThrowCacheRuntimeException(e); } return returnObject; }
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; }
private OperationResult CreateReturnObject(Result result, object value) { OperationResult returnObject = new OperationResult(); returnObject.ReturnResult = result; returnObject.Value = value; return returnObject; }
private OperationResult Concat(string key, object dataToPrepend, ulong casUnique, UpdateType updateType) { if (string.IsNullOrEmpty(key) || dataToPrepend == null) ThrowInvalidArgumentsException(); OperationResult returnObject = new OperationResult(); try { CacheItem getObject = _cache.GetCacheItem(key); if (getObject == null) returnObject = CreateReturnObject(Result.ITEM_NOT_FOUND, null); else if (getObject.Value == null) returnObject = CreateReturnObject(Result.ITEM_NOT_FOUND, null); else { MemcachedItem memCacheItem = (MemcachedItem)getObject.Value; if ((casUnique > 0 && memCacheItem.InternalVersion == casUnique) || casUnique == 0) returnObject = JoinObjects(key, getObject, dataToPrepend, updateType); else returnObject = CreateReturnObject(Result.ITEM_MODIFIED, null); } } catch (Exception e) { ThrowCacheRuntimeException(e); } return returnObject; }
private OperationResult AddItemSuccessfully(string key, uint flags, long expirationTimeInSeconds, object dataBlock) { if (expirationTimeInSeconds < 0) return CreateReturnObject(Result.SUCCESS, 0); OperationResult returnObject = new OperationResult(); try { ulong getVersion = GetLatestVersion(); CacheItem cacheItem = CreateCacheItem(flags, dataBlock, expirationTimeInSeconds, getVersion); _cache.Add(key, cacheItem); returnObject.Value = getVersion; returnObject.ReturnResult = Result.SUCCESS; } catch (Alachisoft.NCache.Runtime.Exceptions.OperationFailedException e) { returnObject = CreateReturnObject(Result.ITEM_EXISTS, null); } catch (Exception e) { ThrowCacheRuntimeException(e); } return returnObject; }
private OperationResult InsertItemSuccessfully(string key, uint flags, long expirationTimeInSeconds, object dataBlock) { if (expirationTimeInSeconds < 0) return CreateReturnObject(Result.SUCCESS, 0); OperationResult returnObject = new OperationResult(); try { ulong getVersion = GetLatestVersion(); CacheItem cacheItem = CreateCacheItem(flags, dataBlock, expirationTimeInSeconds, getVersion); _cache.Insert(key, cacheItem); returnObject.Value = getVersion; returnObject.ReturnResult = Result.SUCCESS; } catch (Exception e) { ThrowCacheRuntimeException(e); } return returnObject; }
public OperationResult Touch(string key, long expirationTimeInSeconds) { if (string.IsNullOrEmpty(key)) ThrowInvalidArgumentsException(); OperationResult returnObject = new OperationResult(); try { CacheItemAttributes attributes = new CacheItemAttributes(); attributes.AbsoluteExpiration = CreateExpirationDate(expirationTimeInSeconds); bool result = _cache.SetAttributes(key, attributes); if (result) returnObject = CreateReturnObject(Result.SUCCESS, null); else returnObject = CreateReturnObject(Result.ITEM_NOT_FOUND, null); } catch (Exception e) { ThrowCacheRuntimeException(e); } return returnObject; }
public OperationResult Flush_All(long expirationTimeInSeconds) { OperationResult returnObject = new OperationResult(); try { if (expirationTimeInSeconds == 0) { ulong getVersion =(ulong) _cache.Get(ItemVersionKey); _cache.Clear(); if (getVersion != null) { _cache.Insert(ItemVersionKey, getVersion); } else { _cache.Insert(ItemVersionKey, ItemVersionValue); } } else { long dueTimeInMilliseconds = expirationTimeInSeconds*1000; _timer = new Timer(FlushExpirationCallBack, null, dueTimeInMilliseconds, 0); } returnObject = CreateReturnObject(Result.SUCCESS, null); } catch (Exception e) { ThrowCacheRuntimeException(e); } return returnObject; }
public OperationResult Delete(string key, ulong casUnique) { if (string.IsNullOrEmpty(key)) ThrowInvalidArgumentsException(); OperationResult returnObject = new OperationResult(); try { if (casUnique == 0) { Object obj = _cache.Remove(key); if (obj == null) returnObject = CreateReturnObject(Result.ITEM_NOT_FOUND, null); else returnObject = CreateReturnObject(Result.SUCCESS, null); } else { CacheItem item = _cache.GetCacheItem(key); if (item == null) returnObject = CreateReturnObject(Result.ITEM_NOT_FOUND, null); else { MemcachedItem memCacheItem = (MemcachedItem)item.Value; if (memCacheItem.InternalVersion != casUnique) { returnObject = CreateReturnObject(Result.ITEM_MODIFIED, null); } else { _cache.Delete(key); returnObject = CreateReturnObject(Result.SUCCESS, null); } } } } catch (Exception e) { ThrowCacheRuntimeException(e); } return returnObject; }
public OperationResult CheckAndSet(string key, uint flags, long expirationTimeInSeconds, ulong casUnique, object dataBlock) { if (string.IsNullOrEmpty(key) || dataBlock == null ) ThrowInvalidArgumentsException(); OperationResult returnObject = new OperationResult(); try { CacheItem getCacheItem = _cache.GetCacheItem(key); if (getCacheItem == null) returnObject = CreateReturnObject(Result.ITEM_NOT_FOUND, null); else { MemcachedItem memCacheItem = (MemcachedItem)getCacheItem.Value; if (memCacheItem.InternalVersion == casUnique) returnObject = InsertItemSuccessfully(key, flags, expirationTimeInSeconds, dataBlock); else returnObject = CreateReturnObject(Result.ITEM_MODIFIED, null); } } catch (Exception e) { ThrowCacheRuntimeException(e); } return returnObject; }