Beispiel #1
0
 public SlicePredicate(SliceRange sliceRange)
 {
     if (sliceRange != null && sliceRange.Count > 0)
     {
         Slice_range = sliceRange;
     }
 }
Beispiel #2
0
 public SlicePredicate(List <byte[]> column_names, SliceRange sliceRange)
     : this(sliceRange)
 {
     if (column_names != null && column_names.Count > 0)
     {
         Column_names = column_names;
     }
 }
Beispiel #3
0
        public void Read(TProtocol iprot)
        {
            TField field;

            iprot.ReadStructBegin();
            while (true)
            {
                field = iprot.ReadFieldBegin();
                if (field.Type == TType.Stop)
                {
                    break;
                }
                switch (field.ID)
                {
                case 1:
                    if (field.Type == TType.List)
                    {
                        {
                            this.column_names = new List <byte[]>();
                            TList _list4 = iprot.ReadListBegin();
                            for (int _i5 = 0; _i5 < _list4.Count; ++_i5)
                            {
                                byte[] _elem6 = null;
                                _elem6 = iprot.ReadBinary();
                                this.column_names.Add(_elem6);
                            }
                            iprot.ReadListEnd();
                        }
                        this.__isset.column_names = true;
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 2:
                    if (field.Type == TType.Struct)
                    {
                        this.slice_range = new SliceRange();
                        this.slice_range.Read(iprot);
                        this.__isset.slice_range = true;
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                default:
                    TProtocolUtil.Skip(iprot, field.Type);
                    break;
                }
                iprot.ReadFieldEnd();
            }
            iprot.ReadStructEnd();
        }
        public void Read(TProtocol iprot)
        {
            TField field;

            iprot.ReadStructBegin();
            while (true)
            {
                field = iprot.ReadFieldBegin();
                if (field.Type == TType.Stop)
                {
                    break;
                }
                switch (field.ID)
                {
                case 1:
                    if (field.Type == TType.List)
                    {
                        {
                            Column_names = new List <byte[]>();
                            TList _list8 = iprot.ReadListBegin();
                            for (int _i9 = 0; _i9 < _list8.Count; ++_i9)
                            {
                                byte[] _elem10 = null;
                                _elem10 = iprot.ReadBinary();
                                Column_names.Add(_elem10);
                            }
                            iprot.ReadListEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 2:
                    if (field.Type == TType.Struct)
                    {
                        Slice_range = new SliceRange();
                        Slice_range.Read(iprot);
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                default:
                    TProtocolUtil.Skip(iprot, field.Type);
                    break;
                }
                iprot.ReadFieldEnd();
            }
            iprot.ReadStructEnd();
        }
        public InventoryFolderBase GetFolderAttributes(UUID folderId)
        {
            if (folderId == UUID.Zero) throw new InventorySecurityException("Not returning folder with ID UUID.Zero");

            try
            {
                ColumnParent columnParent = new ColumnParent();
                columnParent.Column_family = FOLDERS_CF;
                columnParent.Super_column = ByteEncoderHelper.UTF8Encoder.ToByteArray("properties");

                SlicePredicate pred = new SlicePredicate();
                SliceRange range = new SliceRange();
                range.Start = new byte[0];
                range.Finish = new byte[0];
                range.Reversed = false;
                range.Count = int.MaxValue;
                pred.Slice_range = range;

                byte[] folderIdArray = ByteEncoderHelper.GuidEncoder.ToByteArray(folderId.Guid);

                ICluster cluster = AquilesHelper.RetrieveCluster(_clusterName);
                object val =
                    cluster.Execute(new ExecutionBlock(delegate(Apache.Cassandra.Cassandra.Client client)
                    {
                        return client.get_slice(folderIdArray, columnParent, pred, DEFAULT_CONSISTENCY_LEVEL);

                    }), KEYSPACE);

                List<ColumnOrSuperColumn> cols = (List<ColumnOrSuperColumn>)val;
                if (cols.Count == 0)
                {
                    throw new InventoryObjectMissingException(String.Format("Folder with ID {0} could not be found", folderId));
                }

                InventoryFolderBase folder = DecodeFolderBase(folderId.Guid, cols);

                //grab the folder version
                ColumnPath path = new ColumnPath
                {
                    Column = ByteEncoderHelper.UTF8Encoder.ToByteArray("count"),
                    Column_family = FOLDERVERSIONS_CF
                };


                object verVal =
                    cluster.Execute(new ExecutionBlock(delegate(Apache.Cassandra.Cassandra.Client client)
                    {
                        return client.get(folderIdArray, path, DEFAULT_CONSISTENCY_LEVEL);

                    }), KEYSPACE);

                ColumnOrSuperColumn verColumn = (ColumnOrSuperColumn)verVal;

                folder.Version = (ushort)(verColumn.Counter_column.Value % (long)ushort.MaxValue);

                return folder;
            }
            catch (InventoryObjectMissingException e)
            {
//                _log.ErrorFormat("[Inworldz.Data.Inventory.Cassandra] Unable to retrieve folder attributes: {0}", e);
                throw; // produces a duplicate error farther up with more context
            }
            catch (Exception e)
            {
//                _log.ErrorFormat("[Inworldz.Data.Inventory.Cassandra] Unable to retrieve folder attributes: {0}", e);
                throw new InventoryStorageException(e.Message, e); // produces another error farther up with more context
            }
        }
        public InventoryFolderBase GetFolder(UUID folderId)
        {
            if (folderId == UUID.Zero) throw new InventorySecurityException("Not returning folder with ID UUID.Zero");

            try
            {
                ColumnParent columnParent = new ColumnParent();
                columnParent.Column_family = FOLDERS_CF;

                SlicePredicate pred = new SlicePredicate();
                SliceRange range = new SliceRange();
                range.Start = new byte[0];
                range.Finish = new byte[0];
                range.Reversed = false;
                range.Count = int.MaxValue;
                pred.Slice_range = range;

                byte[] folderIdArray = ByteEncoderHelper.GuidEncoder.ToByteArray(folderId.Guid);

                ICluster cluster = AquilesHelper.RetrieveCluster(_clusterName);
                List<ColumnOrSuperColumn> cols = this.RetrieveAllColumnsInChunks(FOLDER_CONTENTS_CHUNK_SZ,
                    folderIdArray, columnParent, pred, DEFAULT_CONSISTENCY_LEVEL);

                if (cols.Count == 0)
                {
                    throw new InventoryObjectMissingException(String.Format("Folder with ID {0} could not be found", folderId));
                }

                ParsedFolderData parsedData = new ParsedFolderData(cols);
                InventoryFolderBase folder = DecodeFolderBase(folderId.Guid, parsedData.Properties.Super_column.Columns);

                if (parsedData.SubFolders != null)
                {
                    foreach (Column col in parsedData.SubFolders.Super_column.Columns)
                    {
                        SubFolderData data = SubFolderData.FromByteArray(col.Value);
                        InventorySubFolderBase folderStub = new InventorySubFolderBase
                        {
                            ID = new UUID(ByteEncoderHelper.GuidEncoder.FromByteArray(col.Name)),
                            Name = data.Name,
                            Owner = folder.Owner,
                            Type = data.Type
                        };

                        folder.SubFolders.Add(folderStub);
                    }
                }

                foreach (ColumnOrSuperColumn itemCol in parsedData.Items)
                {
                    Guid itemId = ByteEncoderHelper.GuidEncoder.FromByteArray(itemCol.Super_column.Name);
                    InventoryItemBase item = this.DecodeInventoryItem(itemCol.Super_column.Columns, itemId, folder.ID.Guid);

                    folder.Items.Add(item);
                }

                //grab the folder version
                try
                {
                    ColumnPath path = new ColumnPath
                    {
                        Column = ByteEncoderHelper.UTF8Encoder.ToByteArray("count"),
                        Column_family = FOLDERVERSIONS_CF
                    };

                    object verVal =
                        cluster.Execute(new ExecutionBlock(delegate(Apache.Cassandra.Cassandra.Client client)
                        {
                            return client.get(folderIdArray, path, DEFAULT_CONSISTENCY_LEVEL);

                        }), KEYSPACE);

                    ColumnOrSuperColumn verColumn = (ColumnOrSuperColumn)verVal;

                    folder.Version = (ushort)(verColumn.Counter_column.Value % (long)ushort.MaxValue);
                }
                catch (Exception e)
                {
                    _log.ErrorFormat("[Inworldz.Data.Inventory.Cassandra] Could not retrieve the version for folder {0} substituting 1: {1}", folderId, e);

                    //version column missing. this is either a partially deleted folder
                    //or the version mutation never happened. Return 1
                    folder.Version = 1;
                }

                return folder;
            }
            catch (InventoryObjectMissingException e)
            {
                _log.ErrorFormat("[Inworldz.Data.Inventory.Cassandra] Unable to retrieve folder attributes: {0}", e);
                throw;
            }
            catch (Exception e)
            {
                _log.ErrorFormat("[Inworldz.Data.Inventory.Cassandra] Unable to retrieve folder attributes: {0}", e);
                throw new InventoryStorageException(e.Message, e);
            }
        }
        /// <summary>
        /// Retrieves the index of all folders owned by this user
        /// </summary>
        /// <param name="ownerId"></param>
        /// <returns></returns>
        private Dictionary<Guid, InventoryFolderBase> GetFolderIndex(UUID ownerId)
        {
            try
            {
                byte[] ownerIdBytes = ByteEncoderHelper.GuidEncoder.ToByteArray(ownerId.Guid);

                ColumnParent columnParent = new ColumnParent();
                columnParent.Column_family = USERFOLDERS_CF;

                SlicePredicate pred = new SlicePredicate();
                SliceRange range = new SliceRange();
                range.Start = new byte[0];
                range.Finish = new byte[0];
                range.Reversed = false;
                range.Count = int.MaxValue;
                pred.Slice_range = range;


                List<ColumnOrSuperColumn> cols = this.RetrieveAllColumnsInChunks(FOLDER_INDEX_CHUNK_SZ,
                    ownerIdBytes, columnParent, pred, DEFAULT_CONSISTENCY_LEVEL);

                Dictionary<Guid, InventoryFolderBase> retIndex = new Dictionary<Guid, InventoryFolderBase>();

                foreach (ColumnOrSuperColumn col in cols)
                {
                    Dictionary<string, Column> columns = this.IndexColumnsByUTF8Name(col.Super_column.Columns);

                    try
                    {
                        InventoryFolderBase folder = new InventoryFolderBase
                        {
                            ID = new UUID(ByteEncoderHelper.GuidEncoder.FromByteArray(col.Super_column.Name)),
                            Level = (InventoryFolderBase.FolderLevel)columns["level"].Value[0],
                            Name = ByteEncoderHelper.UTF8Encoder.FromByteArray(columns["name"].Value),
                            Owner = ownerId,
                            ParentID = new UUID(ByteEncoderHelper.GuidEncoder.FromByteArray(columns["parent_folder"].Value)),
                            Type = (short)ByteEncoderHelper.Int32Encoder.FromByteArray(columns["type"].Value),
                        };

                        retIndex.Add(folder.ID.Guid, folder);
                    }
                    catch (KeyNotFoundException)
                    {
                        //there is a corruption, this folder can not be read
                        _log.ErrorFormat("[Inworldz.Data.Inventory.Cassandra]: Unable to read all columns from folder index item: {0}",
                            new UUID(ByteEncoderHelper.GuidEncoder.FromByteArray(col.Super_column.Name)).ToString());
                    }
                }

                return retIndex;
            }
            catch (Exception e)
            {
                _log.ErrorFormat("[Inworldz.Data.Inventory.Cassandra] Unable to retrieve folder index: {0}", e);
                throw new InventoryStorageException(e.Message, e);
            }
        }
        /// <summary>
        /// Pulls down all folders and collects the list of subfolder
        /// UUIDs for each. Then attempts to read each of the sub folders 
        /// listed in the subfolder index, and removes any indexed subfolders
        /// that are no longer readable due to a partial deletion
        /// </summary>
        /// <param name="ownerId"></param>
        /// <returns></returns>
        public void Maint_RepairSubfolderIndexes(UUID ownerId)
        {
            try
            {
                byte[] ownerIdBytes = ByteEncoderHelper.GuidEncoder.ToByteArray(ownerId.Guid);

                ColumnParent columnParent = new ColumnParent();
                columnParent.Column_family = USERFOLDERS_CF;

                SlicePredicate pred = new SlicePredicate();
                SliceRange range = new SliceRange();
                range.Start = new byte[0];
                range.Finish = new byte[0];
                range.Reversed = false;
                range.Count = int.MaxValue;
                pred.Slice_range = range;


                List<ColumnOrSuperColumn> cols = this.RetrieveAllColumnsInChunks(FOLDER_INDEX_CHUNK_SZ,
                    ownerIdBytes, columnParent, pred, DEFAULT_CONSISTENCY_LEVEL);

                List<InventoryFolderBase> goodIndexFolders = new List<InventoryFolderBase>();

                foreach (ColumnOrSuperColumn col in cols)
                {
                    Dictionary<string, Column> columns = this.IndexColumnsByUTF8Name(col.Super_column.Columns);

                    try
                    {
                        InventoryFolderBase folder = new InventoryFolderBase
                        {
                            ID = new UUID(ByteEncoderHelper.GuidEncoder.FromByteArray(col.Super_column.Name)),
                            Level = (InventoryFolderBase.FolderLevel)columns["level"].Value[0],
                            Name = ByteEncoderHelper.UTF8Encoder.FromByteArray(columns["name"].Value),
                            Owner = ownerId,
                            ParentID = new UUID(ByteEncoderHelper.GuidEncoder.FromByteArray(columns["parent_folder"].Value)),
                            Type = (short)ByteEncoderHelper.Int32Encoder.FromByteArray(columns["type"].Value),
                        };

                        goodIndexFolders.Add(folder);
                    }
                    catch (KeyNotFoundException)
                    {
                        //there is a corruption, this folder can not be read. Ignore since there is
                        //another maint that can fix this that should be run first.
                    }
                }

                List<KeyValuePair<Guid, Guid>> invalidParentChild = new List<KeyValuePair<Guid, Guid>>();

                //for each folder in the index, retrieve it and check for unreadable subfolders
                foreach (InventoryFolderBase indexFolder in goodIndexFolders)
                {
                    try
                    {
                        InventoryFolderBase folder = this.GetFolder(indexFolder.ID);

                        foreach (var subfolder in folder.SubFolders)
                        {
                            try
                            {
                                InventoryFolderBase subFolderDetails = this.GetFolderAttributes(subfolder.ID);
                            }
                            catch (InventoryObjectMissingException)
                            {
                                invalidParentChild.Add(new KeyValuePair<Guid, Guid>(folder.ID.Guid, subfolder.ID.Guid));
                            }
                            catch (InventoryStorageException e)
                            {
                                if (e.InnerException != null && e.InnerException is KeyNotFoundException)
                                {
                                    invalidParentChild.Add(new KeyValuePair<Guid, Guid>(folder.ID.Guid, subfolder.ID.Guid));
                                }
                            }
                            
                        }
                    }
                    catch (Exception e)
                    {
                        //we can't even get the folder, so no subfolders to fix
                        _log.ErrorFormat("[InWorldz.Data.Inventory.Cassandra] Indexed folder {0} could not be retrieved to look for children: {1}", indexFolder.ID, e);
                    }
                }

                _log.InfoFormat("[InWorldz.Data.Inventory.Cassandra][MAINT] Found {0} subfolder indexes to repair", invalidParentChild.Count);

                long timeStamp = Util.UnixTimeSinceEpochInMicroseconds();

                //we couldn't read the folder, pull it from the subfolder list of its parent
                foreach (KeyValuePair<Guid, Guid> parentChildKvp in invalidParentChild)
                {
                    byte[] childIdBytes = ByteEncoderHelper.GuidEncoder.ToByteArray(parentChildKvp.Value);
                    Dictionary<byte[], Dictionary<string, List<Mutation>>> muts = new Dictionary<byte[], Dictionary<string, List<Mutation>>>();

                    GenerateSubfolderIndexDeletion(parentChildKvp.Key, timeStamp, childIdBytes, muts);

                    ICluster cluster = AquilesHelper.RetrieveCluster(_clusterName);
                    cluster.Execute(new ExecutionBlock(delegate(Apache.Cassandra.Cassandra.Client client)
                    {
                        client.batch_mutate(muts, DEFAULT_CONSISTENCY_LEVEL);
                        return null;

                    }), KEYSPACE);
                }
            }
            catch (Exception e)
            {
                _log.ErrorFormat("[Inworldz.Data.Inventory.Cassandra] Unable to repair subfolder index: {0}", e);
                throw new InventoryStorageException(e.Message, e);
            }
        }
        /// <summary>
        /// Retrieves the index of all folders owned by this user and attempts to
        /// find and repair any inconsistencies
        /// </summary>
        /// <param name="ownerId"></param>
        /// <returns></returns>
        public void Maint_RepairFolderIndex(UUID ownerId)
        {
            try
            {
                byte[] ownerIdBytes = ByteEncoderHelper.GuidEncoder.ToByteArray(ownerId.Guid);

                ColumnParent columnParent = new ColumnParent();
                columnParent.Column_family = USERFOLDERS_CF;

                SlicePredicate pred = new SlicePredicate();
                SliceRange range = new SliceRange();
                range.Start = new byte[0];
                range.Finish = new byte[0];
                range.Reversed = false;
                range.Count = int.MaxValue;
                pred.Slice_range = range;


                List<ColumnOrSuperColumn> cols = this.RetrieveAllColumnsInChunks(FOLDER_INDEX_CHUNK_SZ,
                    ownerIdBytes, columnParent, pred, DEFAULT_CONSISTENCY_LEVEL);

                List<Guid> badIndexFolders = new List<Guid>();

                foreach (ColumnOrSuperColumn col in cols)
                {
                    Dictionary<string, Column> columns = this.IndexColumnsByUTF8Name(col.Super_column.Columns);

                    try
                    {
                        InventoryFolderBase folder = new InventoryFolderBase
                        {
                            ID = new UUID(ByteEncoderHelper.GuidEncoder.FromByteArray(col.Super_column.Name)),
                            Level = (InventoryFolderBase.FolderLevel)columns["level"].Value[0],
                            Name = ByteEncoderHelper.UTF8Encoder.FromByteArray(columns["name"].Value),
                            Owner = ownerId,
                            ParentID = new UUID(ByteEncoderHelper.GuidEncoder.FromByteArray(columns["parent_folder"].Value)),
                            Type = (short)ByteEncoderHelper.Int32Encoder.FromByteArray(columns["type"].Value),
                        };
                    }
                    catch (KeyNotFoundException)
                    {
                        //there is a corruption, this folder can not be read
                        badIndexFolders.Add(ByteEncoderHelper.GuidEncoder.FromByteArray(col.Super_column.Name));
                    }
                }

                List<Guid> destroyedFolders = new List<Guid>();
                List<InventoryFolderBase> recoverableFolders = new List<InventoryFolderBase>();

                //for each folder that has a bad index, try to read the folder.
                //if we can read the folder, restore it from the data we have
                //otherwise delete the index, the data is gone
                foreach (Guid id in badIndexFolders)
                {
                    try
                    {
                        InventoryFolderBase folder = this.GetFolderAttributes(new UUID(id));

                        //also verify the parent exists and is readable
                        InventoryFolderBase parentFolder = this.GetFolderAttributes(folder.ParentID);

                        recoverableFolders.Add(folder);
                    }
                    catch (KeyNotFoundException)
                    {
                        destroyedFolders.Add(id);
                    }
                    catch (InventoryObjectMissingException)
                    {
                        destroyedFolders.Add(id);
                    }
                }

                long timeStamp = Util.UnixTimeSinceEpochInMicroseconds();

                foreach (InventoryFolderBase folder in recoverableFolders)
                {
                    //recover anything recoverable
                    this.CreateFolderInternal(folder, timeStamp);
                }

                foreach (Guid id in destroyedFolders)
                {
                    this.RemoveFromIndex(ownerId.Guid, id, timeStamp);
                }
            }
            catch (Exception e)
            {
                _log.ErrorFormat("[Inworldz.Data.Inventory.Cassandra] Unable to recover folder index: {0}", e);
                throw new InventoryStorageException(e.Message, e);
            }
        }
        private List<UUID> GetActiveGestureItemIds(UUID userId)
        {
            try
            {
                ColumnParent columnParent = new ColumnParent();
                columnParent.Column_family = USERACTIVEGESTURES_CF;

                SlicePredicate pred = new SlicePredicate();
                SliceRange range = new SliceRange();
                range.Start = new byte[0];
                range.Finish = new byte[0];
                range.Reversed = false;
                range.Count = int.MaxValue;
                pred.Slice_range = range;

                ICluster cluster = AquilesHelper.RetrieveCluster(_clusterName);

                object retobj =
                    cluster.Execute(new ExecutionBlock(delegate(Apache.Cassandra.Cassandra.Client client)
                    {
                        byte[] userIdBytes = ByteEncoderHelper.GuidEncoder.ToByteArray(userId.Guid);
                        return client.get_slice(userIdBytes, columnParent, pred, DEFAULT_CONSISTENCY_LEVEL);
                    
                    }), KEYSPACE);

                List<ColumnOrSuperColumn> cols = (List<ColumnOrSuperColumn>)retobj;
                List<UUID> ret = new List<UUID>();

                foreach (ColumnOrSuperColumn col in cols)
                {
                    ret.Add(new UUID(ByteEncoderHelper.GuidEncoder.FromByteArray(col.Column.Name)));
                }

                return ret;
            }
            catch (Exception e)
            {
                throw new InventoryStorageException(e.Message, e);
            }
        }
        public Guid FindItemParentFolderId(UUID itemId)
        {
            ColumnParent columnParent = new ColumnParent();
            columnParent.Column_family = ITEMPARENTS_CF;

            SlicePredicate pred = new SlicePredicate();
            SliceRange range = new SliceRange();
            range.Start = new byte[0];
            range.Finish = new byte[0];
            range.Reversed = false;
            range.Count = int.MaxValue;
            pred.Slice_range = range;

            byte[] itemIdArray = ByteEncoderHelper.GuidEncoder.ToByteArray(itemId.Guid);

            ICluster cluster = AquilesHelper.RetrieveCluster(_clusterName);

            object val = 
                cluster.Execute(new ExecutionBlock(delegate(Apache.Cassandra.Cassandra.Client client)
                {
                    return client.get_slice(itemIdArray, columnParent, pred, DEFAULT_CONSISTENCY_LEVEL);

                }), KEYSPACE);

            List<ColumnOrSuperColumn> indexCols = (List<ColumnOrSuperColumn>)val;

            //no index means the item doesnt exist
            if (indexCols.Count == 0)
            {
                return Guid.Empty;
            }

            var indexedColsByName = this.IndexColumnsByUTF8Name(indexCols);

            return ByteEncoderHelper.GuidEncoder.FromByteArray(indexedColsByName["parent"].Value);
        }
        public InventoryItemBase GetItem(UUID itemId, UUID parentFolderHint)
        {
            //Retrieving an item requires a lookup of the parent folder followed by 
            //a retrieval of the item. This was a consious decision made since the 
            //inventory item data currently takes up the most space and a
            //duplication of this data to prevent the index lookup 
            //would be expensive in terms of space required

            try
            {
                Guid parentId;
                
                if (parentFolderHint != UUID.Zero)
                {
                    parentId = parentFolderHint.Guid;
                }
                else
                {
                    parentId = FindItemParentFolderId(itemId);
                }

                if (parentId == Guid.Empty)
                {
                    throw new InventoryObjectMissingException(String.Format("Item with ID {0} could not be found", itemId), "Item was not found in the index");
                }

                //try to retrieve the item. note that even though we have an index there is a chance we will
                //not have the item data due to a race condition between index mutation and item mutation
                byte[] itemIdBytes = ByteEncoderHelper.GuidEncoder.ToByteArray(itemId.Guid);
                byte[] folderIdBytes = ByteEncoderHelper.GuidEncoder.ToByteArray(parentId);

                ColumnParent columnParent = new ColumnParent();
                columnParent.Column_family = FOLDERS_CF;
                columnParent.Super_column = itemIdBytes;

                SlicePredicate pred = new SlicePredicate();
                SliceRange range = new SliceRange();
                range.Start = new byte[0];
                range.Finish = new byte[0];
                range.Reversed = false;
                range.Count = int.MaxValue;
                pred.Slice_range = range;

                ICluster cluster = AquilesHelper.RetrieveCluster(_clusterName);

                object itemDataObj =
                    cluster.Execute(new ExecutionBlock(delegate(Apache.Cassandra.Cassandra.Client client)
                    {
                        return client.get_slice(folderIdBytes, columnParent, pred, DEFAULT_CONSISTENCY_LEVEL);

                    }), KEYSPACE);

                List<ColumnOrSuperColumn> itemCols = (List<ColumnOrSuperColumn>)itemDataObj;

                if (itemCols.Count == 0)
                {
                    throw new InventoryObjectMissingException(String.Format("Item with ID {0} could not be found", itemId), "Item was not found in its folder");
                }

                InventoryItemBase item = this.DecodeInventoryItem(itemCols, itemId.Guid, parentId);

                return item;
            }
            catch (InventoryStorageException)
            {
                throw;
            }
            catch (Exception e)
            {
                _log.ErrorFormat("[Inworldz.Data.Inventory.Cassandra] Unable to retrieve item {0}: {1}", itemId, e);
                throw new InventoryStorageException(e.Message, e);
            }
        }
 public void Read(TProtocol iprot)
 {
     TField field;
       iprot.ReadStructBegin();
       while (true)
       {
     field = iprot.ReadFieldBegin();
     if (field.Type == TType.Stop) {
       break;
     }
     switch (field.ID)
     {
       case 1:
     if (field.Type == TType.List) {
       {
         Column_names = new List<byte[]>();
         TList _list4 = iprot.ReadListBegin();
         for( int _i5 = 0; _i5 < _list4.Count; ++_i5)
         {
           byte[] _elem6 = null;
           _elem6 = iprot.ReadBinary();
           Column_names.Add(_elem6);
         }
         iprot.ReadListEnd();
       }
     } else {
       TProtocolUtil.Skip(iprot, field.Type);
     }
     break;
       case 2:
     if (field.Type == TType.Struct) {
       Slice_range = new SliceRange();
       Slice_range.Read(iprot);
     } else {
       TProtocolUtil.Skip(iprot, field.Type);
     }
     break;
       default:
     TProtocolUtil.Skip(iprot, field.Type);
     break;
     }
     iprot.ReadFieldEnd();
       }
       iprot.ReadStructEnd();
 }
 public SlicePredicate(List<byte[]> column_names, SliceRange sliceRange)
     : this(sliceRange)
 {
     if (column_names != null && column_names.Count > 0)
         Column_names = column_names;
 }
 public SlicePredicate(SliceRange sliceRange)
 {
     if (sliceRange != null && sliceRange.Count > 0)
         Slice_range = sliceRange;
 }