Example #1
0
        public void GetBlock()
        {
            robot.MoveTo(robot.Center);

            GetBlockAction action = new GetBlockAction(robot, workingSpace.GetCartridgeSlot(0));

            TimeSpan endTime = action.Execute(TimeSpan.FromSeconds(1));

            Assert.AreEqual(workingSpace.GetCartridgeSlot(0).CatchHole, workingSpace.Robot.Effector);

            float    distance = 223.439026f;
            TimeSpan moveTime = TimeSpan.FromSeconds(distance / speed);

            Assert.AreEqual(moveTime + TimeSpan.FromSeconds(2), endTime);

            Assert.AreEqual(0, robot.CurrentBlock);
            Assert.AreEqual(9, workingSpace.GetCartridgeSlot(0).Cartridge.CurrentCount);
        }
Example #2
0
        void AttachedNode_MessageReceived(Node node, IncomingMessage message)
        {
            message.IfPayloadIs <Types.Block>(async bk =>
            {
                var result = await new HandleBlockAction(bk).Publish();

                switch (result.BkResultEnum)
                {
                case BlockChain.BlockVerificationHelper.BkResultEnum.Accepted:
                    foreach (var other in Nodes)
                    {
                        if (other != AttachedNode && other.State == NodeState.HandShaked)
                        {
                            other.SendMessageAsync(bk);
                        }
                    }
                    break;

                case BlockChain.BlockVerificationHelper.BkResultEnum.AcceptedOrphan:
                    StatusMessageProducer.LastOrphan = bk.header.blockNumber;
                    node.SendMessageAsync(new GetDataPayload(new InventoryVector[] {
                        new InventoryVector(InventoryType.MSG_BLOCK, result.MissingParent)
                    }));
                    break;

                case BlockChain.BlockVerificationHelper.BkResultEnum.Rejected:
                    if (result.MissingParent != null)
                    {
                        node.SendMessageAsync(new GetDataPayload(new InventoryVector[] {
                            new InventoryVector(InventoryType.MSG_BLOCK, result.MissingParent)
                        }));
                    }

                    //TODO: refine possible state (don't reject blocks that were requested by GetTip; reply with DUPLICATE instead of INVALID, ...)
                    node.SendMessageAsync(new RejectPayload()
                    {
                        Hash    = Consensus.Merkle.blockHeaderHasher.Invoke(bk.header),
                        Code    = RejectCode.INVALID,
                        Message = "bk"
                    });
                    break;
                }
            });

            message.IfPayloadIs <GetTipPayload>(getTip =>
            {
                var tip = _BlockChain.Tip;

                if (tip != null)
                {
                    var bk = new GetBlockAction()
                    {
                        BkHash = tip.Key
                    }.Publish().Result;

                    if (bk != null)
                    {
                        NodeServerTrace.Information("Sending tip: " + tip.Value.header.blockNumber);
                        node.SendMessageAsync(bk);
                    }
                    else
                    {
                        NodeServerTrace.Information("Missing or invalid tip block requested");
                    }
                }
                else
                {
                    NodeServerTrace.Information("No tip to send");
                }
            });

            message.IfPayloadIs <GetDataPayload>(getData =>
            {
                foreach (var inventory in getData.Inventory.Where(i => i.Type == InventoryType.MSG_BLOCK))
                {
                    var bk = new GetBlockAction()
                    {
                        BkHash = inventory.Hash
                    }.Publish().Result;

                    if (bk != null)
                    {
                        NodeServerTrace.Information("Sending block: " + bk.header.blockNumber);
                        node.SendMessageAsync(bk);
                    }
                    else
                    {
                        NodeServerTrace.Information("Missing or invalid block requested");
                    }
                }
            });
        }