コード例 #1
0
        private void UploadThread()
        {
            for (; ;)
            {
                Thread.Sleep(1000 * 1);
                if (this.State == ManagerState.Stop)
                {
                    return;
                }

                {
                    UploadItem item = null;

                    lock (this.ThisLock)
                    {
                        if (_settings.UploadItems.Count > 0)
                        {
                            item = _settings.UploadItems[0];
                        }
                    }

                    try
                    {
                        if (item != null)
                        {
                            ArraySegment <byte> buffer = new ArraySegment <byte>();

                            try
                            {
                                if (item.Type == "Profile")
                                {
                                    buffer = ContentConverter.ToProfileBlock(item.Profile);
                                }
                                else if (item.Type == "SignatureMessage")
                                {
                                    buffer = ContentConverter.ToSignatureMessageBlock(item.SignatureMessage, item.ExchangePublicKey);
                                }
                                else if (item.Type == "WikiDocument")
                                {
                                    buffer = ContentConverter.ToWikiDocumentBlock(item.WikiDocument);
                                }
                                else if (item.Type == "ChatTopic")
                                {
                                    buffer = ContentConverter.ToChatTopicBlock(item.ChatTopic);
                                }
                                else if (item.Type == "ChatMessage")
                                {
                                    buffer = ContentConverter.ToChatMessageBlock(item.ChatMessage);
                                }

                                Key key = null;

                                {
                                    if (_hashAlgorithm == HashAlgorithm.Sha256)
                                    {
                                        key = new Key(Sha256.ComputeHash(buffer), _hashAlgorithm);
                                    }

                                    this.Lock(key);
                                }

                                _cacheManager[key] = buffer;
                                _connectionsManager.Upload(key);

                                var miner = new Miner(CashAlgorithm.Version1, item.MiningLimit, item.MiningTime);

                                var task = Task.Factory.StartNew(() =>
                                {
                                    if (item.Type == "Profile")
                                    {
                                        var metadata = new ProfileMetadata(item.Profile.CreationTime, key, item.DigitalSignature);
                                        _connectionsManager.Upload(metadata);
                                    }
                                    else if (item.Type == "SignatureMessage")
                                    {
                                        var metadata = new SignatureMessageMetadata(item.SignatureMessage.Signature, item.SignatureMessage.CreationTime, key, miner, item.DigitalSignature);
                                        _connectionsManager.Upload(metadata);
                                    }
                                    else if (item.Type == "WikiDocument")
                                    {
                                        var metadata = new WikiDocumentMetadata(item.WikiDocument.Tag, item.WikiDocument.CreationTime, key, miner, item.DigitalSignature);
                                        _connectionsManager.Upload(metadata);
                                    }
                                    else if (item.Type == "ChatTopic")
                                    {
                                        var metadata = new ChatTopicMetadata(item.ChatTopic.Tag, item.ChatTopic.CreationTime, key, miner, item.DigitalSignature);
                                        _connectionsManager.Upload(metadata);
                                    }
                                    else if (item.Type == "ChatMessage")
                                    {
                                        var metadata = new ChatMessageMetadata(item.ChatMessage.Tag, item.ChatMessage.CreationTime, key, miner, item.DigitalSignature);
                                        _connectionsManager.Upload(metadata);
                                    }
                                });

                                while (!task.IsCompleted)
                                {
                                    if (this.State == ManagerState.Stop)
                                    {
                                        miner.Cancel();
                                    }

                                    lock (this.ThisLock)
                                    {
                                        if (!_settings.UploadItems.Contains(item))
                                        {
                                            miner.Cancel();
                                        }
                                    }

                                    Thread.Sleep(1000);
                                }

                                if (task.Exception != null)
                                {
                                    throw task.Exception;
                                }

                                lock (this.ThisLock)
                                {
                                    _settings.UploadItems.Remove(item);
                                }
                            }
                            finally
                            {
                                if (buffer.Array != null)
                                {
                                    _bufferManager.ReturnBuffer(buffer.Array);
                                }
                            }
                        }
                    }
                    catch (Exception)
                    {
                    }
                }
            }
        }
コード例 #2
0
        public void Test_Miner()
        {
            //{
            //    var key = NetworkConverter.FromHexString("e0ee19d617ee6ea9ea592afbdf71bafba6eecde2beba0d3cdc51419522fe5dbdf18f6830081be1615969b1fe43344fac3c312cd86a487cb1bd04f2c44cddca11");
            //    var value = NetworkConverter.FromHexString("01010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101");

            //    var count = Verify_1(key, value);
            //}

            {
                Miner miner = new Miner(CashAlgorithm.Version1, -1, new TimeSpan(0, 0, 1));

                Cash cash = null;

                Stopwatch sw = new Stopwatch();
                sw.Start();

                using (MemoryStream stream = new MemoryStream(NetworkConverter.FromHexString("0101010101010101")))
                {
                    cash = miner.Create(stream);
                }

                sw.Stop();
                Assert.IsTrue(sw.ElapsedMilliseconds < 1000 * 30);
            }

            {
                Miner miner = new Miner(CashAlgorithm.Version1, 20, new TimeSpan(1, 0, 0));

                Cash cash = null;

                using (MemoryStream stream = new MemoryStream(NetworkConverter.FromHexString("0101010101010101")))
                {
                    cash = miner.Create(stream);

                    stream.Seek(0, SeekOrigin.Begin);
                    Assert.IsTrue(Miner.Verify(cash, stream) >= 20);
                }
            }

            {
                Miner miner = new Miner(CashAlgorithm.Version1, 0, TimeSpan.Zero);

                Cash cash = null;

                using (MemoryStream stream = new MemoryStream(NetworkConverter.FromHexString("0101010101010101")))
                {
                    cash = miner.Create(stream);
                }

                Assert.IsTrue(cash == null);
            }

            {
                Stopwatch sw = new Stopwatch();
                sw.Start();

                Assert.Throws <AggregateException>(() =>
                {
                    Miner miner = new Miner(CashAlgorithm.Version1, -1, new TimeSpan(1, 0, 0));

                    var task = Task.Factory.StartNew(() =>
                    {
                        Cash cash = null;

                        using (MemoryStream stream = new MemoryStream(NetworkConverter.FromHexString("0101010101010101")))
                        {
                            cash = miner.Create(stream);
                        }
                    });

                    Thread.Sleep(1000);

                    miner.Cancel();

                    task.Wait();
                });

                sw.Stop();
                Assert.IsTrue(sw.ElapsedMilliseconds < 1000 * 30);
            }
        }