Inheritance: MonoBehaviour
示例#1
0
 public HaRequestType(TargetCaller targetCaller, ObjectSerializer objectSerializer, sbyte id, bool unpack)
 {
     this._targetCaller     = targetCaller;
     this._objectSerializer = objectSerializer;
     this._id     = id;
     this._unpack = unpack;
 }
示例#2
0
        private void RegisterHandshake()
        {
            TargetCaller <Master, HandshakeResult> handshakeTarget = (master, context, input, target) => master.handshake(input.readLong(), null);
            ObjectSerializer <HandshakeResult>     handshakeResultObjectSerializer = (responseObject, result) =>
            {
                result.writeLong(responseObject.txChecksum());
                result.writeLong(responseObject.epoch());
            };

            Register(HaRequestTypes_Type.Handshake, handshakeTarget, handshakeResultObjectSerializer);
        }
示例#3
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldHandleNoForensicsSpecifiedInFullBackupRequest() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void ShouldHandleNoForensicsSpecifiedInFullBackupRequest()
        {
            TheBackupInterface backup = mock(typeof(TheBackupInterface));
            RequestContext     ctx    = new RequestContext(0, 1, 0, -1, 12);
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("unchecked") org.neo4j.com.TargetCaller<org.neo4j.backup.TheBackupInterface, Void> targetCaller = (org.neo4j.com.TargetCaller<org.neo4j.backup.TheBackupInterface,Void>) org.neo4j.backup.impl.BackupClient.BackupRequestType.FULL_BACKUP.getTargetCaller();
            TargetCaller <TheBackupInterface, Void> targetCaller = (TargetCaller <TheBackupInterface, Void>)BackupRequestType.FULL_BACKUP.TargetCaller;

            targetCaller.Call(backup, ctx, EMPTY_BUFFER, null);
            verify(backup).fullBackup(any(typeof(StoreWriter)), eq(false));
        }
示例#4
0
        private void RegisterEndLockSession()
        {
            // NOTE <1>: A 'false' argument for 'unpack' means we won't unpack the response.
            // We do this because END_LOCK_SESSION request can be send in 3 cases:
            //  1) transaction committed successfully
            //  2) transaction rolled back successfully
            //  3) transaction was terminated
            // Master's response for this call is an obligation to pull up to a specified txId.
            // Processing/unpacking of this response is not needed in all 3 cases:
            //  1) committed transaction pulls transaction stream as part of COMMIT call
            //  2) rolled back transaction does not care about reading any more
            //  3) terminated transaction does not care about reading any more
            TargetCaller <Master, Void> endLockSessionTarget = (master, context, input, target) => master.endLockSession(context, readBoolean(input));

            Register(HaRequestTypes_Type.EndLockSession, endLockSessionTarget, VOID_SERIALIZER, false);
        }
示例#5
0
        private void RegisterCommit(LogEntryReader <ReadableClosablePositionAwareChannel> entryReader)
        {
            TargetCaller <Master, long> commitTarget = (master, context, input, target) =>
            {
                readString(input);                   // Always neostorexadatasource

                TransactionRepresentation tx;
                try
                {
                    Deserializer <TransactionRepresentation> deserializer = new Protocol.TransactionRepresentationDeserializer(entryReader);
                    tx = deserializer.read(input, null);
                }
                catch (IOException e)
                {
                    throw new Exception(e);
                }

                return(master.commit(context, tx));
            };

            Register(HaRequestTypes_Type.Commit, commitTarget, LONG_SERIALIZER);
        }
示例#6
0
        private void RegisterAllocateIds()
        {
            TargetCaller <Master, IdAllocation> allocateIdTarget = (master, context, input, target) =>
            {
                IdType idType = IdType.values()[input.readByte()];
                return(master.allocateIds(context, idType));
            };
            ObjectSerializer <IdAllocation> allocateIdSerializer = (idAllocation, result) =>
            {
                IdRange idRange = idAllocation.IdRange;
                result.writeInt(idRange.DefragIds.length);
                foreach (long id in idRange.DefragIds)
                {
                    result.writeLong(id);
                }
                result.writeLong(idRange.RangeStart);
                result.writeInt(idRange.RangeLength);
                result.writeLong(idAllocation.HighestIdInUse);
                result.writeLong(idAllocation.DefragCount);
            };

            Register(HaRequestTypes_Type.AllocateIds, allocateIdTarget, allocateIdSerializer);
        }
示例#7
0
 protected internal virtual void Register <A, B, C>(HaRequestTypes_Type type, TargetCaller <A, B> targetCaller, ObjectSerializer <C> objectSerializer, bool unpack)
 {
     Debug.Assert(_types[type.ordinal()] == null);
     _types[type.ordinal()] = new HaRequestType(targetCaller, objectSerializer, (sbyte)type.ordinal(), unpack);
 }
示例#8
0
 protected internal virtual void Register <A, B, C>(HaRequestTypes_Type type, TargetCaller <A, B> targetCaller, ObjectSerializer <C> objectSerializer)
 {
     Register(type, targetCaller, objectSerializer, true);
 }
示例#9
0
        private void RegisterCreateRelationshipType()
        {
            TargetCaller <Master, int> createRelationshipTypeTarget = (master, context, input, target) => master.createRelationshipType(context, readString(input));

            Register(HaRequestTypes_Type.CreateRelationshipType, createRelationshipTypeTarget, INTEGER_SERIALIZER);
        }
示例#10
0
        private void RegisterCreatePropertyKey()
        {
            TargetCaller <Master, int> createPropertyKeyTarget = (master, context, input, target) => master.createPropertyKey(context, readString(input));

            Register(HaRequestTypes_Type.CreatePropertyKey, createPropertyKeyTarget, INTEGER_SERIALIZER);
        }
示例#11
0
        private void RegisterNewLockSession()
        {
            TargetCaller <Master, Void> newLockSessionTarget = (master, context, input, target) => master.newLockSession(context);

            Register(HaRequestTypes_Type.NewLockSession, newLockSessionTarget, VOID_SERIALIZER);
        }
示例#12
0
        private void RegisterCopyStore()
        {
            TargetCaller <Master, Void> copyStoreTarget = (master, context, input, target) => master.copyStore(context, new ToNetworkStoreWriter(target, new Monitors()));

            Register(HaRequestTypes_Type.CopyStore, copyStoreTarget, VOID_SERIALIZER, false);
        }
示例#13
0
        private void RegisterPullUpdates()
        {
            TargetCaller <Master, Void> pullUpdatesTarget = (master, context, input, target) => master.pullUpdates(context);

            Register(HaRequestTypes_Type.PullUpdates, pullUpdatesTarget, VOID_SERIALIZER);
        }