Esempio n. 1
0
        internal override void Visit(UpdateVersionMaxCommitTsRequest req)
        {
            VersionEntry verEntry = req.RemoteVerEntry;

            if (verEntry == null)
            {
                throw new TransactionException("The version entry should be referenced for main-memory k-v.");
            }

            if (verEntry.VersionKey != req.VersionKey)
            {
                throw new TransactionException("The referenced version entry has been recycled for new data.");
            }

            while (Interlocked.CompareExchange(ref verEntry.latch, 1, 0) != 0)
            {
                ;
            }

            verEntry.MaxCommitTs = Math.Max(req.MaxCommitTs, verEntry.MaxCommitTs);
            VersionEntry.CopyValue(verEntry, req.LocalVerEntry);

            Interlocked.Exchange(ref verEntry.latch, 0);

            req.Result   = req.LocalVerEntry;
            req.Finished = true;
        }
Esempio n. 2
0
        internal override void Visit(UpdateVersionMaxCommitTsRequest req)
        {
            VersionEntry verEntry = req.RemoteVerEntry;

            if (verEntry == null)
            {
                ConcurrentDictionary <long, VersionEntry> versionList = null;
                if (!this.dict.TryGetValue(req.RecordKey, out versionList))
                {
                    throw new TransactionException("The specified record does not exist.");
                }

                if (!versionList.TryGetValue(req.VersionKey, out verEntry))
                {
                    throw new TransactionException("The specified version does not exist.");
                }
            }

            Debug.Assert(verEntry.VersionKey == req.VersionKey);

            //int ticket = verEntry.EnterQueuedLatch();
            verEntry.WriteLock();
            Interlocked.Exchange(
                ref verEntry.MaxCommitTs,
                Math.Max(req.MaxCommitTs, Interlocked.Read(ref verEntry.MaxCommitTs)));
            VersionEntry.CopyFromRemote(verEntry, req.LocalVerEntry);
            //verEntry.ExitQueuedLatch(ticket);
            verEntry.UnWriteLock();

            req.Result   = req.LocalVerEntry;
            req.Finished = true;
        }
        internal override void Visit(UpdateVersionMaxCommitTsRequest req)
        {
            this.CQLExecuteWithIfApplied(string.Format(CassandraVersionTable.CQL_UPDATE_MAX_COMMIT_TIMESTAMP,
                                                       req.TableId, req.MaxCommitTs, req.RecordKey.ToString(), req.VersionKey));

            req.Result   = this.GetVersionEntryByKey(req.TableId, req.RecordKey, req.VersionKey);
            req.Finished = true;
        }
 internal override void Visit(UpdateVersionMaxCommitTsRequest req)
 {
     byte[][] returnBytes = req.Result as byte[][];
     req.Result = returnBytes == null || returnBytes.Length < 2 ?
                  null :
                  VersionEntry.Deserialize(
         req.VersionKey,
         returnBytes.ValueBytes(), req.LocalVerEntry);
 }
Esempio n. 5
0
        internal override void Visit(UpdateVersionMaxCommitTsRequest req)
        {
            VersionEntry ve = this.GetVersionEntryByKey(req.TableId, req.RecordKey, req.VersionKey, req.LocalVerEntry);

            if (ve.MaxCommitTs < req.MaxCommitTs)
            {
                this.CQLExecute(string.Format(PartitionedCassandraVersionTable.CQL_UPDATE_MAX_COMMIT_TIMESTAMP,
                                              req.TableId, req.MaxCommitTs, req.RecordKey.ToString(), req.VersionKey));
                ve.MaxCommitTs = req.MaxCommitTs;
            }

            req.Result   = ve;
            req.Finished = true;
        }
        internal override void Visit(UpdateVersionMaxCommitTsRequest req)
        {
            string sha1 = this.redisLuaScriptManager.GetLuaScriptSha1(LuaScriptName.UPDATE_VERSION_MAX_COMMIT_TS);

            this.HashId = req.RecordKey as string;

            byte[][] keysAndArgs =
            {
                Encoding.ASCII.GetBytes(this.HashId),
                BitConverter.GetBytes(req.VersionKey),
                BitConverter.GetBytes(req.MaxCommitTs),
                RedisVersionDb.NEGATIVE_ONE_BYTES,
            };

            this.RedisReq = new RedisRequest(keysAndArgs, sha1, 1, RedisRequestType.EvalSha)
            {
                ParentRequest = req
            };
        }
        internal override void Visit(UpdateVersionMaxCommitTsRequest req)
        {
            VersionEntry verEntry = req.RemoteVerEntry;

            if (verEntry == null)
            {
                Dictionary <long, VersionEntry> versionList = null;
                if (!this.dict.TryGetValue(req.RecordKey, out versionList) ||
                    !versionList.TryGetValue(req.VersionKey, out verEntry))
                {
                    throw new TransactionException("The specified version does not exist.");
                }
            }

            // Only update the max commit time when uploaded commit time is larger than the version's
            verEntry.MaxCommitTs = Math.Max(verEntry.MaxCommitTs, req.MaxCommitTs);
            VersionEntry.CopyValue(verEntry, req.LocalVerEntry);

            req.Result   = req.LocalVerEntry;
            req.Finished = true;
        }
        internal override void Visit(UpdateVersionMaxCommitTsRequest req)
        {
            string sha1   = this.redisLuaManager.GetLuaScriptSha1(LuaScriptName.UPDATE_VERSION_MAX_COMMIT_TS);
            string hashId = req.RecordKey.ToString();

            if (this.redisVersionDbMode == RedisVersionDbMode.Cluster)
            {
                hashId = RedisVersionDb.PACK_KEY(RedisVersionDb.VER_KEY_PREFIX, hashId);
            }

            byte[][] keysAndArgs =
            {
                Encoding.ASCII.GetBytes(hashId),
                BitConverter.GetBytes(req.VersionKey),
                BitConverter.GetBytes(req.MaxCommitTs),
                RedisVersionDb.NEGATIVE_ONE_BYTES,
            };

            RedisRequest redisReq = this.NextRedisRequest();

            redisReq.Set(keysAndArgs, sha1, 1, RedisRequestType.EvalSha);
            redisReq.ParentRequest = req;
        }
Esempio n. 9
0
 internal virtual void Visit(UpdateVersionMaxCommitTsRequest req)
 {
 }