Пример #1
0
        protected override async Task AddTransaction(long transactionId, byte[] mutationHash, Mutation mutation)
        {
            foreach (Record record in mutation.Records)
            {
                RecordKey key = RecordKey.Parse(record.Key);

                await ExecuteAsync(@"
                        UPDATE  Records
                        SET     Type = @type,
                                Name = @name
                        WHERE   Key = @key",
                    new Dictionary<string, object>()
                    {
                        ["@key"] = record.Key.ToByteArray(),
                        ["@type"] = (int)key.RecordType,
                        ["@name"] = key.Name
                    });

                await ExecuteAsync(@"
                        INSERT INTO RecordMutations
                        (RecordKey, TransactionId, MutationHash)
                        VALUES (@recordKey, @transactionId, @mutationHash)",
                    new Dictionary<string, object>()
                    {
                        ["@recordKey"] = record.Key.ToByteArray(),
                        ["@transactionId"] = transactionId,
                        ["@mutationHash"] = mutationHash
                    });
            }
        }
        public void Mutation_Success()
        {
            Mutation mutation = new Mutation(
                binaryData[0],
                new[]
                {
                    new Record(binaryData[1], binaryData[2], binaryData[3]),
                    new Record(binaryData[4], null, binaryData[5]),
                },
                binaryData[6]);

            byte[] result = MessageSerializer.SerializeMutation(mutation);

            Mutation finalMutation = MessageSerializer.DeserializeMutation(new ByteString(result));

            Assert.Equal(244, result.Length);
            Assert.Equal(mutation.Records.Count, finalMutation.Records.Count);
            Assert.Equal(mutation.Records[0].Key, finalMutation.Records[0].Key);
            Assert.Equal(mutation.Records[0].Value, finalMutation.Records[0].Value);
            Assert.Equal(mutation.Records[0].Version, finalMutation.Records[0].Version);
            Assert.Equal(mutation.Records[1].Key, finalMutation.Records[1].Key);
            Assert.Equal(mutation.Records[1].Value, finalMutation.Records[1].Value);
            Assert.Equal(mutation.Records[1].Version, finalMutation.Records[1].Version);
            Assert.Equal(mutation.Namespace, finalMutation.Namespace);
            Assert.Equal(mutation.Metadata, finalMutation.Metadata);
        }
Пример #3
0
Файл: C.cs Проект: Thomsch/EVA
 protected override IMutation PreSpawnMutation()
 {
     Mutation result = new Mutation();
     result.AddGeneticModifier(new Blur(Set.ALL, new Set(new [] {"scale"}), 0.5F));
     result.AddGeneticModifier(new SingleBlur(new Set(new [] {"root"}),new Set(new [] {"lifeduration"}), 100.0F));
     result.AddGeneticModifier(new SingleBlur(new Set(new [] {"root"}), new Set(new [] {"speed"}), 0.2F));
     return result;
 }
Пример #4
0
 public void notifyInitialized(Mutation mutation)
 {
     //mutations[initializedMutations++] = mutation;
     initializedMutations++;
     if(initializedMutations==totalMutations){
         curHealth = maxHealth;
     }
 }
Пример #5
0
Файл: D.cs Проект: Thomsch/EVA
    protected override IMutation PreSpawnMutation()
    {
        Mutation result = new Mutation();
        result.AddGeneticModifier(new Blur(Set.ALL, new Set(new [] {"scale"}), 0.2F));

        // It won't have much effect since the joints force to be aligned.
        result.AddGeneticModifier(new Blur(Set.ALL, new Set(new[] { "rotation" }), 10));
        result.AddGeneticModifier(new SingleBlur(new Set(new [] {"root"}),new Set(new [] {"lifeduration"}), 500));
        return result;
    }
Пример #6
0
        public void Ctor_assigns_property_Description()
        {
            // Arrange
            var someString = "any string";

            // Act
            var sut = new Mutation<ClassToTest>(someString, d => d.IntProperty = 2);

            // Assert
            Assert.Equal(someString, sut.Description);
        }
Пример #7
0
        public void Apply_calls_mutationToApply_on_argument()
        {
            // Arrange
            var initialValue = 4;
            var initial = new ClassToTest(initialValue);
            var sut = new Mutation<ClassToTest>("some string", d => d.IntProperty += 2);

            // Act
               sut.Apply(initial);

            // Assert
            Assert.Equal(initialValue + 2, initial.IntProperty);
        }
        public async Task PostTransaction_EmptyMutation()
        {
            Dictionary<string, long> accounts = new Dictionary<string, long>();

            TransactionValidator validator = CreateValidator(accounts);
            Mutation mutation = new Mutation(
                validNamespace,
                new Record[0],
                ByteString.Empty);

            TransactionInvalidException exception = await Assert.ThrowsAsync<TransactionInvalidException>(
                () => validator.PostTransaction(new ByteString(MessageSerializer.SerializeMutation(mutation)), new SignatureEvidence[0]));
            Assert.Equal("InvalidMutation", exception.Reason);
        }
Пример #9
0
        public static ParsedMutation Parse(Mutation mutation)
        {
            List<AccountStatus> accountMutations = new List<AccountStatus>();
            List<KeyValuePair<RecordKey, ByteString>> dataRecords = new List<KeyValuePair<RecordKey, ByteString>>();

            foreach (Record record in mutation.Records)
            {
                // This is used for optimistic concurrency and does not participate in the validation
                if (record.Value == null)
                    continue;

                try
                {
                    RecordKey key = RecordKey.Parse(record.Key);
                    switch (key.RecordType)
                    {
                        case RecordType.Account:
                            accountMutations.Add(AccountStatus.FromRecord(key, record));
                            break;
                        case RecordType.Data:
                            dataRecords.Add(new KeyValuePair<RecordKey, ByteString>(key, record.Value));
                            break;
                    }
                }
                catch (ArgumentOutOfRangeException ex) when (ex.ParamName == "keyData")
                {
                    // Deserializing and re-serializing the record gives a different result
                    throw new TransactionInvalidException("NonCanonicalSerialization");
                }
                catch (ArgumentOutOfRangeException ex) when (ex.ParamName == "path")
                {
                    // The path is invalid
                    throw new TransactionInvalidException("InvalidPath");
                }
                catch (ArgumentOutOfRangeException ex) when (ex.ParamName == "recordType")
                {
                    // The specified record type is unknown
                    throw new TransactionInvalidException("InvalidRecord");
                }
                catch (ArgumentOutOfRangeException ex) when (ex.ParamName == "record")
                {
                    // The value of an ACC record could not be deserialized
                    throw new TransactionInvalidException("InvalidRecord");
                }
            }

            return new ParsedMutation(accountMutations, dataRecords);
        }
Пример #10
0
        public void ClearTextReporter_ShouldPrintGreenAboveThresholdHigh()
        {
            string output    = "";
            var    chalkMock = new Mock <IChalk>(MockBehavior.Strict);

            chalkMock.Setup(x => x.Default(It.IsAny <string>())).Callback((string text) => { output += text; });
            chalkMock.Setup(x => x.Green(It.IsAny <string>())).Callback((string text) => { output += text; });

            var tree         = CSharpSyntaxTree.ParseText("void M(){ int i = 0 + 8; }");
            var originalNode = tree.GetRoot().DescendantNodes().OfType <BinaryExpressionSyntax>().First();

            var mutation = new Mutation()
            {
                OriginalNode    = originalNode,
                ReplacementNode = SyntaxFactory.BinaryExpression(SyntaxKind.SubtractExpression, originalNode.Left, originalNode.Right),
                DisplayName     = "This name should display",
                Type            = Mutator.Arithmetic
            };

            var target = new ClearTextReporter(new StrykerOptions(), chalkMock.Object);

            var folder = new FolderComposite()
            {
                Name         = "RootFolder",
                RelativePath = "RootFolder",
                FullPath     = "C://RootFolder",
            };

            folder.Add(new FileLeaf()
            {
                Name         = "SomeFile.cs",
                RelativePath = "RootFolder/SomeFile.cs",
                RelativePathToProjectFile = "SomeFile.cs",
                FullPath = "C://RootFolder/SomeFile.cs",
                Mutants  = new Collection <Mutant>()
                {
                    new Mutant()
                    {
                        ResultStatus = MutantStatus.Killed, Mutation = mutation
                    },
                }
            });

            target.OnAllMutantsTested(folder);

            chalkMock.Verify(x => x.Green(It.IsAny <string>()), Times.Exactly(2));
        }
Пример #11
0
        static T Get <T>(uint id)
        {
            T ret = default(T);

            // prevent string decryptors from invoking this method
            if (!Equals(Assembly.GetCallingAssembly(), Assembly.GetExecutingAssembly()) ||
                new StackTrace().GetFrame(1).GetMethod().DeclaringType == typeof(RuntimeMethodHandle))
            {
                return(ret);
            }

            // demutate the id
            id = (uint)Mutation.Placeholder((int)id);

            // get the type
            uint type = id >> 30;

            // get actual id
            id  &= 0x3fffffff;
            id <<= 2;

            if (type == Mutation.KeyI0)
            {
                // read a string preceded by a 32bit length int
                int len = buffer[id++] | (buffer[id++] << 8) | (buffer[id++] << 16) | (buffer[id++] << 24);
                ret = (T)(object)string.Intern(Encoding.UTF8.GetString(buffer, (int)id, len));
            }
            // NOTE: Assume little-endian
            else if (type == Mutation.KeyI1)
            {
                //read an int
                var v = new T[1];
                Buffer.BlockCopy(buffer, (int)id, v, 0, Mutation.Value <int>());
                ret = v[0];
            }
            else if (type == Mutation.KeyI2)
            {
                // read an array
                int   structLength = buffer[id++] | (buffer[id++] << 8) | (buffer[id++] << 16) | (buffer[id++] << 24);
                int   arrayLength  = buffer[id++] | (buffer[id++] << 8) | (buffer[id++] << 16) | (buffer[id++] << 24);
                Array v            = Array.CreateInstance(typeof(T).GetElementType(), arrayLength);
                Buffer.BlockCopy(buffer, (int)id, v, 0, structLength - 4);
                ret = (T)(object)v;
            }

            return(ret);
        }
Пример #12
0
        public override void DeleteCells(string table, string rowKey, bool writeToWal, List <string> columns, Dictionary <string, string> attributes)
        {
            byte[] tableName = Encode(table);
            byte[] row       = Encode(rowKey);
            Dictionary <byte[], byte[]> encodedAttributes = EncodeAttributes(attributes);
            List <Mutation>             mutations         = new List <Mutation>();

            foreach (string column in columns)
            {
                Mutation mutation = new Mutation();
                mutation.IsDelete   = true;
                mutation.WriteToWAL = writeToWal;
                mutation.Column     = Encode(column);
                mutations.Add(mutation);
            }
            client.mutateRow(tableName, row, mutations, encodedAttributes);
        }
Пример #13
0
        private async Task AddRecords(params string[] keys)
        {
            Mutation mutation = new Mutation(
                ByteString.Empty,
                keys.Select(key => new Record(
                    new ByteString(Encoding.UTF8.GetBytes(key)),
                    ByteString.Empty,
                    ByteString.Empty)),
                ByteString.Empty);

            Transaction transaction = new Transaction(
                new ByteString(MessageSerializer.SerializeMutation(mutation)),
                new DateTime(),
                ByteString.Empty);

            await store.AddTransactions(new[] { new ByteString(MessageSerializer.SerializeTransaction(transaction)) });
        }
        /// <summary>Snippet for MutateRowAsync</summary>
        public async Task MutateRow2Async()
        {
            // Snippet: MutateRowAsync(string, ByteString, IEnumerable<Mutation>, string, CallSettings)
            // Additional: MutateRowAsync(string, ByteString, IEnumerable<Mutation>, string, CancellationToken)
            // Create client
            BigtableServiceApiClient bigtableServiceApiClient = await BigtableServiceApiClient.CreateAsync();

            // Initialize request argument(s)
            string                 tableName    = "projects/[PROJECT]/instances/[INSTANCE]/tables/[TABLE]";
            ByteString             rowKey       = ByteString.Empty;
            IEnumerable <Mutation> mutations    = new Mutation[] { new Mutation(), };
            string                 appProfileId = "";
            // Make the request
            MutateRowResponse response = await bigtableServiceApiClient.MutateRowAsync(tableName, rowKey, mutations, appProfileId);

            // End snippet
        }
Пример #15
0
        /// <summary>Snippet for CommitAsync</summary>
        public async Task Commit2Async()
        {
            // Snippet: CommitAsync(string, CommitRequest.Types.Mode, IEnumerable<Mutation>, CallSettings)
            // Additional: CommitAsync(string, CommitRequest.Types.Mode, IEnumerable<Mutation>, CancellationToken)
            // Create client
            DatastoreClient datastoreClient = await DatastoreClient.CreateAsync();

            // Initialize request argument(s)
            string projectId = "";

            CommitRequest.Types.Mode mode      = CommitRequest.Types.Mode.Unspecified;
            IEnumerable <Mutation>   mutations = new Mutation[] { new Mutation(), };
            // Make the request
            CommitResponse response = await datastoreClient.CommitAsync(projectId, mode, mutations);

            // End snippet
        }
Пример #16
0
        /// <summary>
        /// This Funds a wallet from a External Bank Deposit.
        /// </summary>
        /// <param name="connection">ES connection</param>
        /// <param name="walletAccount">Account name of a wallet</param>
        /// <param name="CashAccount">The Cash account</param>
        /// <param name="amount">Transaction amount</param>
        /// <param name="currency">Currency ISO 3</param>
        /// <param name="description">Free test filed</param>
        /// <param name="description2">Free text field</param>
        public void HandleWalletDeposit(IEventStoreConnection connection, string walletAccount, string CashAccount, decimal amount, string currency, string description, string description2)
        {
            // reset the objects
            ResetManager();



            // get the last mutations of the both Accounts
            walletAccountLastEvent = Mutation.FromJson(AccountManager.GetLastEvent(connection, walletAccount));
            cashAccountLastEvent   = Mutation.FromJson(AccountManager.GetLastEvent(connection, CashAccount));



            //
            // TODO Must check if the CashAccount is of the type Cash and the Wallet Account of the Type Wallet. If not then do not continue.
            //


            // Create a Posting Object.
            posting = MutationEventManager.CreatePosting(walletAccountLastEvent, cashAccountLastEvent, Enums.MutationTypes.Deposit, Enums.MutationEntryTypes.Dr, amount, currency, description, description2);
            Mutation walletAccountNewEvent = posting.Mutations[0];
            Mutation CashAccountNewEvent   = posting.Mutations[1];


            // create an eventStore Event for the 2 Postings
            var myEvent1 = new EventData(Guid.Parse(walletAccountNewEvent.MutationId), EventTypes.WalletFunded.ToString(), true, Encoding.UTF8.GetBytes(Mutation.ToJson(walletAccountNewEvent)), null);
            var myEvent2 = new EventData(Guid.Parse(CashAccountNewEvent.MutationId), EventTypes.WalletFunded.ToString(), true, Encoding.UTF8.GetBytes(Mutation.ToJson(CashAccountNewEvent)), null);

            // TODO validate the balance the wallet account can not be negative

            // TODO Calculate the fee

            // TODO transaction learn about it

            // this takes to long 165 ms..
            // Events is a Array. One day need to try to experiment with this.
            // First Credit the Cash Account
            connection.AppendToStreamAsync(CashAccount, CashAccountNewEvent.PreviousEventNumber, myEvent2).Wait();
            //Then Debit the Wallet Account
            connection.AppendToStreamAsync(walletAccount, walletAccountNewEvent.PreviousEventNumber, myEvent1).Wait();

            // var st = new System.Diagnostics.Stopwatch();
            // st.Start();
            // st.Stop();
            // System.Diagnostics.Debug.WriteLine($"Mutation created: {st.ElapsedMilliseconds} ms");
        }
Пример #17
0
        /// <summary>
        /// Sets the edges corresponding to predicates on the node with the given uid for deletion. This
        /// function returns a new <see cref="Mutation"/> object with the edges set. It is the caller's responsibility to
        /// run the mutation by calling <see cref="Transaction.MutateAsync(Mutation)"/>.
        /// </summary>
        /// <param name="mu">Mutation to add edges to</param>
        /// <param name="uid">uid uid of the node</param>
        /// <param name="predicates">predicates predicates of the edges to remove</param>
        /// <returns>a new Mutation object with the edges set</returns>
        public static Mutation CreateDeleteEdgesMutation(Mutation mu, String uid, params string[] predicates)
        {
            Mutation b = new Mutation(mu);

            foreach (var predicate in predicates)
            {
                b.Del.Add(new NQuad()
                {
                    Subject     = uid,
                    Predicate   = predicate,
                    ObjectValue = new Value {
                        DefaultVal = "_STAR_ALL"
                    }
                });
            }
            return(b);
        }
Пример #18
0
        public void test_commit_after_CommitNow()
        {
            Assert.ThrowsAsync <TxnFinishedException>(async() =>
            {
                using (var txn = _client.NewTransaction())
                {
                    var mut = new Mutation
                    {
                        SetNquads = ByteString.CopyFromUtf8("<_:bob> <name> \"Bob\" ."),
                        CommitNow = true
                    };

                    await txn.MutateAsync(mut);
                    await txn.CommitAsync();
                }
            });
        }
Пример #19
0
        public async Task test_delete()
        {
            using (var txn = _client.NewTransaction())
            {
                var mutation = new Mutation
                {
                    SetNquads = ByteString.CopyFromUtf8("<_:bob> <name> \"Bob\" .")
                };

                var ag = await txn.MutateAsync(mutation);

                string bob = ag.Uids["bob"];

                string query = new StringBuilder()
                               .AppendLine("{")
                               .AppendLine($"find_bob(func: uid({bob}))")
                               .AppendLine("{")
                               .AppendLine("name")
                               .AppendLine("}")
                               .AppendLine("}")
                               .ToString();

                var resp = await txn.QueryAsync(query);

                var json = JObject.Parse(resp.Json.ToStringUtf8());

                var arr = json.GetValue("find_bob") as JArray;
                Assert.IsTrue(arr.Count > 0);

                mutation = new Mutation
                {
                    DelNquads = ByteString.CopyFromUtf8($"<{bob}> * * .")
                };

                await txn.MutateAsync(mutation);

                resp = await txn.QueryAsync(query);

                json = JObject.Parse(resp.Json.ToStringUtf8());

                arr = json.GetValue("find_bob") as JArray;
                Assert.IsTrue(arr.Count == 0);

                await txn.CommitAsync();
            }
        }
Пример #20
0
        /// <summary>Snippet for MutateRowAsync</summary>
        public async Task MutateRow2ResourceNamesAsync()
        {
            // Snippet: MutateRowAsync(TableName, ByteString, IEnumerable<Mutation>, string, CallSettings)
            // Additional: MutateRowAsync(TableName, ByteString, IEnumerable<Mutation>, string, CancellationToken)
            // Create client
            BigtableClient bigtableClient = await BigtableClient.CreateAsync();

            // Initialize request argument(s)
            TableName              tableName = TableName.FromProjectInstanceTable("[PROJECT]", "[INSTANCE]", "[TABLE]");
            ByteString             rowKey    = ByteString.Empty;
            IEnumerable <Mutation> mutations = new Mutation[] { new Mutation(), };
            string appProfileId = "";
            // Make the request
            MutateRowResponse response = await bigtableClient.MutateRowAsync(tableName, rowKey, mutations, appProfileId);

            // End snippet
        }
        /// <inheritdoc/>
        public async Task <IPullRequestReviewCommentModel> PostPendingReviewComment(
            ILocalRepositoryModel localRepository,
            IAccount user,
            string pendingReviewId,
            string body,
            string commitId,
            string path,
            int position)
        {
            var address = HostAddress.Create(localRepository.CloneUrl.Host);
            var graphql = await graphqlFactory.CreateConnection(address);

            var comment = new AddPullRequestReviewCommentInput
            {
                Body                = body,
                CommitOID           = commitId,
                Path                = path,
                Position            = position,
                PullRequestReviewId = pendingReviewId,
            };

            var addComment = new Mutation()
                             .AddPullRequestReviewComment(comment)
                             .Select(x => new PullRequestReviewCommentModel
            {
                Id                  = x.Comment.DatabaseId.Value,
                NodeId              = x.Comment.Id,
                Body                = x.Comment.Body,
                CommitId            = x.Comment.Commit.Oid,
                Path                = x.Comment.Path,
                Position            = x.Comment.Position,
                CreatedAt           = x.Comment.CreatedAt.Value,
                DiffHunk            = x.Comment.DiffHunk,
                OriginalPosition    = x.Comment.OriginalPosition,
                OriginalCommitId    = x.Comment.OriginalCommit.Oid,
                PullRequestReviewId = x.Comment.PullRequestReview.DatabaseId.Value,
                User                = user,
                IsPending           = true,
            });

            var result = await graphql.Run(addComment);

            await usageTracker.IncrementCounter(x => x.NumberOfPRReviewDiffViewInlineCommentPost);

            return(result);
        }
Пример #22
0
        static int Main(string[] args)
        {
            var l = (uint)Mutation.KeyI0;

            uint[] q = Mutation.Placeholder(new uint[Mutation.KeyI0]);

            GCHandle h = Decrypt(q, (uint)Mutation.KeyI1);
            var      b = (byte[])h.Target;

            var assemblyLoadCtx = Type.GetType("System.Runtime.Loader.AssemblyLoadContext");

            if (assemblyLoadCtx != null)
            {
                var assemblyLoadCtxDef  = assemblyLoadCtx.GetProperty("Default")?.GetValue(null);
                var assemblyLoadCtxLoad = assemblyLoadCtx.GetMethod("LoadFromStream", new Type[] { typeof(Stream) });
                if (assemblyLoadCtxDef != null && assemblyLoadCtxLoad != null)
                {
                    assemblyLoad = (datas) => (Assembly)assemblyLoadCtxLoad.Invoke(assemblyLoadCtxDef, new object[] { new MemoryStream(datas) });
                }
            }
            Assembly a = assemblyLoad(b);

            Array.Clear(b, 0, b.Length);
            h.Free();
            Array.Clear(q, 0, q.Length);

            var m = typeof(CompressorCompat).Module;

            key = m.ResolveSignature(Mutation.KeyI2);
            AppDomain.CurrentDomain.AssemblyResolve += Resolve;

            MethodBase e = a.ManifestModule.ResolveMethod(key[0] | (key[1] << 8) | (key[2] << 16) | (key[3] << 24));
            var        g = new object[e.GetParameters().Length];

            if (g.Length != 0)
            {
                g[0] = args;
            }
            object r = e.Invoke(null, g);

            if (r is int)
            {
                return((int)r);
            }
            return(0);
        }
        public async Task Move_ValidInput_CallsGameManager()
        {
            // arrange
            var moveInput = new MoveInput
            {
                GameId        = "abcdef",
                Player        = Player.Cross,
                BoardPosition = new Position(0, 0),
                TilePosition  = new Position(0, 0)
            };

            var gameManagerMock = new Mock <IGameManager>();

            gameManagerMock
            .Setup(m => m.Move(It.IsAny <Move>(), CancellationToken.None))
            .ReturnsAsync(new MoveResult
            {
                Move              = moveInput.ToMove(),
                InvalidReason     = null,
                IsValid           = false,
                MoveFinishedGame  = false,
                MoveFinishedBoard = false,
            });

            var eventSenderMock = new Mock <IEventSender>();

            eventSenderMock
            .Setup(m => m.SendAsync(It.IsAny <IEventMessage>()))
            .Returns(Task.CompletedTask)
            .Verifiable();

            var mutation = new Mutation();


            //act
            var result = await mutation.Move(
                moveInput,
                gameManagerMock.Object,
                eventSenderMock.Object,
                CancellationToken.None);

            //assert
            gameManagerMock.Verify(
                m => m.Move(It.IsAny <Move>(), CancellationToken.None),
                Times.Once);
        }
Пример #24
0
    public static void CreateBabyMonkey(MonkeyDNA motherDNA, MonkeyDNA fatherDNA, Transform mother)
    {
        MonkeyDNA dna       = new MonkeyDNA();
        Mutation  mutation  = new Mutation();
        Crossover crossover = new Crossover();

        dna.speed          = mutation.MutateGene(crossover.Cross(motherDNA.speed, fatherDNA.speed), DNA.SPEED_MIN, DNA.SPEED_MAX);
        dna.foodViewRange  = mutation.MutateGene(crossover.Cross(motherDNA.foodViewRange, fatherDNA.foodViewRange), DNA.FOODVIEWRANGE_MIN, DNA.FOODVIEWRANGE_MAX);
        dna.waterViewRange = mutation.MutateGene(crossover.Cross(motherDNA.waterViewRange, fatherDNA.waterViewRange), DNA.WATERVIEWRANGE_MIN, DNA.FOODVIEWRANGE_MAX);

        dna.sex = mutation.RandomizeSex();

        var monkey = Instantiate(Instance.babyMonkey, mother.position, Quaternion.identity).GetComponent <BabyMonkey>();

        AnimalStatistics.Instance.AddAnimal(monkey.matureMaleMonkey);
        monkey.Initialize(dna);
    }
        private static GCHandle Decrypt(uint[] data, uint seed)
        {
            var   w = new uint[0x10];
            var   k = new uint[0x10];
            ulong s = seed;

            for (var i = 0; i < 0x10; i++)
            {
                s    = s * s % 0x143fc089;
                k[i] = (uint)s;
                w[i] = (uint)(s * s % 0x444d56fb);
            }
            Mutation.Crypt(w, k);
            Array.Clear(k, 0, 0x10);

            var  b = new byte[data.Length << 2];
            uint h = 0;

            for (var i = 0; i < data.Length; i++)
            {
                var d = data[i] ^ w[i & 0xf];
                w[i & 0xf] = (w[i & 0xf] ^ d) + 0x3ddb2819;
                b[h + 0]   = (byte)(d >> 0);
                b[h + 1]   = (byte)(d >> 8);
                b[h + 2]   = (byte)(d >> 16);
                b[h + 3]   = (byte)(d >> 24);
                h         += 4;
            }
            Array.Clear(w, 0, 0x10);
            var j = Lzma.Decompress(b);

            Array.Clear(b, 0, b.Length);

            var g = GCHandle.Alloc(j, GCHandleType.Pinned);
            var z = (uint)(s % 0x8a5cb7);

            for (var i = 0; i < j.Length; i++)
            {
                j[i] ^= (byte)s;
                if ((i & 0xff) == 0)
                {
                    s = s * s % 0x8a5cb7;
                }
            }
            return(g);
        }
Пример #26
0
        public void Star_And_Unstar_Project()
        {
            var viewerHasStarredQuery = new Query().Repository(Helper.Username, _repoName).Select(repository => repository.ViewerHasStarred);

            var viewerHasStarred = Connection.Run(viewerHasStarredQuery).Result;

            Assert.False(viewerHasStarred);

            var clientMutationId = "abc123";

            var addStarQuery = new Mutation().AddStar(new AddStarInput
            {
                ClientMutationId = clientMutationId,
                StarrableId      = _repositoryId
            }).Select(payload => new
            {
                payload.ClientMutationId,
                StarrableId = payload.Starrable.Id,
                payload.Starrable.ViewerHasStarred
            });

            var addStarResult = Connection.Run(addStarQuery).Result;

            Assert.Equal(addStarResult.ClientMutationId, clientMutationId);
            Assert.Equal(addStarResult.StarrableId, _repositoryId);
            Assert.True(addStarResult.ViewerHasStarred);

            clientMutationId = "def456";

            var removeStarQuery = new Mutation().RemoveStar(new RemoveStarInput()
            {
                ClientMutationId = clientMutationId,
                StarrableId      = _repositoryId
            }).Select(payload => new
            {
                payload.ClientMutationId,
                StarrableId = payload.Starrable.Id,
                payload.Starrable.ViewerHasStarred
            });

            var removeStarResult = Connection.Run(removeStarQuery).Result;

            Assert.Equal(removeStarResult.ClientMutationId, clientMutationId);
            Assert.Equal(removeStarResult.StarrableId, _repositoryId);
            Assert.False(removeStarResult.ViewerHasStarred);
        }
Пример #27
0
        private async Task AddRecords(params string[] keys)
        {
            Mutation mutation = new Mutation(
                ByteString.Empty,
                keys.Select(key => new Record(
                                new ByteString(Encoding.UTF8.GetBytes(key)),
                                ByteString.Empty,
                                ByteString.Empty)),
                ByteString.Empty);

            Transaction transaction = new Transaction(
                new ByteString(MessageSerializer.SerializeMutation(mutation)),
                new DateTime(),
                ByteString.Empty);

            await store.AddTransactions(new[] { new ByteString(MessageSerializer.SerializeTransaction(transaction)) });
        }
Пример #28
0
        public async void CreateCampaign_ReturnsCreatedCampaign()
        {
            // Arrange
            await using var context = _tb.DatabaseContext;
            var campaignInput = new Campaign
            {
                Name        = "New Campaign",
                Description = "Created in Unit Test"
            };
            var mutation = new Mutation();

            // Act
            var campaign = await mutation.CreateCampaign(context, "MutationTests User 2", campaignInput);

            // Assert
            Assert.True(string.Equals("MutationTests User 2", campaign.UserId));
        }
Пример #29
0
        public void Create_And_Delete_Project()
        {
            var projectName      = "ProjectName_" + _ticks;
            var projectDesc      = "ProjectDesc_" + _ticks;
            var clientMutationId = "abc123";

            var createProjectQuery = new Mutation()
                                     .CreateProject(new CreateProjectInput()
            {
                Name    = projectName,
                OwnerId = _repositoryId,

                //TODO: This is not required but the code fails if we leave this empty
                ClientMutationId = clientMutationId,
                Body             = projectDesc
            })
                                     .Select(payload => new { payload.ClientMutationId, ProjectId = payload.Project.Id, ProjectName = payload.Project.Name, ProjectOwnerId = payload.Project.Owner.Id });

            var projectData = Connection.Run(createProjectQuery).Result;

            Assert.Equal(projectData.ClientMutationId, clientMutationId);
            Assert.Equal(projectData.ProjectName, projectName);
            Assert.Equal(projectData.ProjectOwnerId, _repositoryId);

            clientMutationId = "def456";

            var deleteProjectQuery = new Mutation()
                                     .DeleteProject(new DeleteProjectInput()
            {
                ProjectId = projectData.ProjectId,

                //TODO: This is not required but the code fails if we leave this empty
                ClientMutationId = clientMutationId
            })
                                     .Select(payload => new
            {
                ProjectOwnerId = payload.Owner.Id,
                payload.ClientMutationId,
            });

            var deleteResult = Connection.Run(deleteProjectQuery).Result;

            Assert.Equal(deleteResult.ClientMutationId, clientMutationId);
            Assert.Equal(deleteResult.ProjectOwnerId, _repositoryId);
        }
Пример #30
0
        public void Simulate(int count, int length, int min, int max, int maxGeneration)
        {
            m_Population = new Population <T>(count, length, min, max);
            m_Population.Evaluate(Fitness);

            m_Population.Save(Filename, false);
            if (Debug != null && (DebugMask & DebugMask.First) != 0)
            {
                Debug.Log(m_Population);
            }

            while (m_Population.Generation < maxGeneration)
            {
                m_Population.Elite(Elitism);

                do
                {
                    IChromosome <T> parent1 = Selection.Select(m_Population);
                    IChromosome <T> parent2 = Selection.Select(m_Population);

                    IChromosome <T> offspring1, offspring2;
                    Crossover.Crossover(parent1, parent2, out offspring1, out offspring2);

                    Mutation.Mutate(ref offspring1, min, max);
                    Mutation.Mutate(ref offspring2, min, max);

                    m_Population.AddChromosomeInNewPopulation(offspring1);
                    m_Population.AddChromosomeInNewPopulation(offspring2);
                } while (!m_Population.IsFullNewGeneration);

                m_Population.SwapGeneration();
                m_Population.Evaluate(Fitness);

                m_Population.Save(Filename, true);
                if (Debug != null && (DebugMask & DebugMask.Step) != 0)
                {
                    Debug.Log(m_Population);
                }
            }

            if (Debug != null && (DebugMask & DebugMask.Last) != 0)
            {
                Debug.Log(m_Population);
            }
        }
Пример #31
0
        public async Task <Assigned> MutateAsync(Mutation mutation, CancellationToken cancellationToken)
        {
            if (readOnly)
            {
                throw new Exception("A Read-Only Transaction cannot be mutated");
            }

            if (finished)
            {
                throw new Exception("A finished Transaction cannot be mutated");
            }

            mutated = true;

            mutation.StartTs = context.StartTs;

            Assigned assigned;

            try
            {
                assigned = await client.MutateAsync(request : mutation, cancellationToken : cancellationToken);

                if (mutation.CommitNow)
                {
                    finished = true;
                }

                MergeContext(assigned.Context);
            }
            catch (RpcException e)
            {
                try
                {
                    await DiscardAsync(cancellationToken);
                }
                catch
                {
                    // TODO Problems discarding the Transaction shouldn't go unnoticed ...
                }

                throw e;
            }

            return(assigned);
        }
Пример #32
0
        async Task <bool> DeletePackageVersion(IConnection connection, ID versionId)
        {
            try
            {
                var input = new DeletePackageVersionInput {
                    PackageVersionId = versionId, ClientMutationId = "GrpTool"
                };
                var mutation = new Mutation().DeletePackageVersion(input).Select(p => p.Success).Compile();
                var payload  = await connection.Run(mutation);

                return(payload.Value);
            }
            catch (GraphQLException e)
            {
                Console.WriteLine(e.Message);
                return(false);
            }
        }
        private string GetPayingAddress(Mutation outgoingTransaction)
        {
            try
            {
                string metadata = Encoding.UTF8.GetString(outgoingTransaction.Metadata.ToByteArray(), 0, outgoingTransaction.Metadata.Value.Count);

                JObject root = JObject.Parse(metadata);
                return(BitcoinAddress.Create((string)root["routing"], network).ToString());
            }
            catch (JsonReaderException)
            {
                return(null);
            }
            catch (FormatException)
            {
                return(null);
            }
        }
Пример #34
0
        public override void Update(string table, string rowKey, bool writeToWal, Dictionary <string, string> fieldNameValues, Dictionary <string, string> attributes)
        {
            byte[] tableName = Encode(table);
            byte[] row       = Encode(rowKey);
            Dictionary <byte[], byte[]> encodedAttributes = EncodeAttributes(attributes);
            List <Mutation>             mutations         = new List <Mutation>();

            foreach (KeyValuePair <String, String> pair in fieldNameValues)
            {
                Mutation mutation = new Mutation();
                mutation.IsDelete   = false;
                mutation.WriteToWAL = writeToWal;
                mutation.Column     = Encode(pair.Key);
                mutation.Value      = Encode(pair.Value);
                mutations.Add(mutation);
            }
            client.mutateRow(tableName, row, mutations, encodedAttributes);
        }
        /// <summary>Snippet for CheckAndMutateRowAsync</summary>
        public async Task CheckAndMutateRow1Async()
        {
            // Snippet: CheckAndMutateRowAsync(string, ByteString, RowFilter, IEnumerable<Mutation>, IEnumerable<Mutation>, CallSettings)
            // Additional: CheckAndMutateRowAsync(string, ByteString, RowFilter, IEnumerable<Mutation>, IEnumerable<Mutation>, CancellationToken)
            // Create client
            BigtableServiceApiClient bigtableServiceApiClient = await BigtableServiceApiClient.CreateAsync();

            // Initialize request argument(s)
            string                 tableName       = "projects/[PROJECT]/instances/[INSTANCE]/tables/[TABLE]";
            ByteString             rowKey          = ByteString.Empty;
            RowFilter              predicateFilter = new RowFilter();
            IEnumerable <Mutation> trueMutations   = new Mutation[] { new Mutation(), };
            IEnumerable <Mutation> falseMutations  = new Mutation[] { new Mutation(), };
            // Make the request
            CheckAndMutateRowResponse response = await bigtableServiceApiClient.CheckAndMutateRowAsync(tableName, rowKey, predicateFilter, trueMutations, falseMutations);

            // End snippet
        }
        /// <inheritdoc/>
        public async Task CancelPendingReview(
            ILocalRepositoryModel localRepository,
            string reviewId)
        {
            var address = HostAddress.Create(localRepository.CloneUrl.Host);
            var graphql = await graphqlFactory.CreateConnection(address);

            var delete = new DeletePullRequestReviewInput
            {
                PullRequestReviewId = reviewId,
            };

            var deleteReview = new Mutation()
                               .DeletePullRequestReview(delete)
                               .Select(x => x.ClientMutationId);

            await graphql.Run(deleteReview);
        }
Пример #37
0
        /// <summary>Snippet for CheckAndMutateRowAsync</summary>
        public async Task CheckAndMutateRow1ResourceNamesAsync()
        {
            // Snippet: CheckAndMutateRowAsync(TableName, ByteString, RowFilter, IEnumerable<Mutation>, IEnumerable<Mutation>, CallSettings)
            // Additional: CheckAndMutateRowAsync(TableName, ByteString, RowFilter, IEnumerable<Mutation>, IEnumerable<Mutation>, CancellationToken)
            // Create client
            BigtableClient bigtableClient = await BigtableClient.CreateAsync();

            // Initialize request argument(s)
            TableName              tableName       = TableName.FromProjectInstanceTable("[PROJECT]", "[INSTANCE]", "[TABLE]");
            ByteString             rowKey          = ByteString.Empty;
            RowFilter              predicateFilter = new RowFilter();
            IEnumerable <Mutation> trueMutations   = new Mutation[] { new Mutation(), };
            IEnumerable <Mutation> falseMutations  = new Mutation[] { new Mutation(), };
            // Make the request
            CheckAndMutateRowResponse response = await bigtableClient.CheckAndMutateRowAsync(tableName, rowKey, predicateFilter, trueMutations, falseMutations);

            // End snippet
        }
Пример #38
0
        public static Mutation CreateMutation(MutationMethod mutationMethod, MutationMethod[] mutationMethods,
                                              int[][] population, double mutationProbability, Random random)
        {
            Mutation mutation = mutationMethod switch
            {
                MutationMethod.RSM => new RSMutation(mutationProbability, population, random),
                MutationMethod.TWORS => new TWORSMutation(mutationProbability, population, random),
                MutationMethod.CIM => new CIMutation(mutationProbability, population, random),
                MutationMethod.THROAS => new THROASMutation(mutationProbability, population, random),
                MutationMethod.THRORS => new THRORSMutation(mutationProbability, population, random),
                MutationMethod.MAM => new MAMutation(mutationMethods, mutationProbability, population, random),
                MutationMethod.MRM => new MRMutation(mutationMethods, mutationProbability, population, random),
                _ => throw new AggregateException("Wrong mutation method name")
            };

            return(mutation);
        }
    }
Пример #39
0
    //sets up the initial GA
    public GeneticAlgo CreateGA(string[][] _sampleGenomes)
    {
        System.Random r = new System.Random(Time.frameCount);
        //specify the numbers of genes to the population.

        string selectType = "god mode";
        string mutateType = "randomChoice";
        string crossType  = "OnePt";

        Encoder    encoder    = _encode;
        Fitness    fitness    = new Fitness("");
        Population population = new Population(_childCount, encoder._symbols, samplePopulation: _sampleGenomes, variableGenomeLength: true);
        Selection  selection  = new Selection(selectType);
        CrossOver  crossover  = new CrossOver(crossType);
        Mutation   mutation   = new Mutation(mutateType, _mutationRate);

        return(new GeneticAlgo(encoder, fitness, population, selection, crossover, mutation));
    }
Пример #40
0
        public override DecimalArrayChromosome FindOptimum()
        {
            var best = new DecimalArrayChromosome(Constants.ChromosomeSize)
            {
                Fitness = decimal.MaxValue
            };

            for (var i = 0; i < IterationLimit; i++)
            {
                var nextGeneration = new Population <DecimalArrayChromosome>(PopulationSize);

                if (Elitism)
                {
                    nextGeneration.Add(GetPopulationBest());
                }

                while (nextGeneration.Count() < PopulationSize)
                {
                    var selectedFromPopulation = Selection.Select(Population);
                    var childChromosome        =
                        Crossover.Cross(selectedFromPopulation.First(), selectedFromPopulation[1]);
                    childChromosome         = Mutation.Mutate(childChromosome);
                    childChromosome.Fitness = FitnessFunction.GetValue(childChromosome);

                    nextGeneration.Add(childChromosome);
                }

                Population = nextGeneration;
                var populationBest = GetPopulationBest();

                if (populationBest.Fitness < best.Fitness)
                {
                    best = populationBest;
                    Console.WriteLine("Iteration: " + i + ", Best fitness: " + populationBest.Fitness + ", " + best);
                }

                if (populationBest.Fitness < FitnessTerminator)
                {
                    break;
                }
            }

            return(best);
        }
        public async Task PostTransaction_MaxKeySize()
        {
            Dictionary<string, long> accounts = new Dictionary<string, long>();

            TransactionValidator validator = CreateValidator(accounts);
            Mutation mutation = new Mutation(
                validNamespace,
                new Record[]
                {
                    new Record(
                        ByteString.Parse(new string('a', 513 * 2)),
                        new ByteString(BitConverter.GetBytes(100L).Reverse()),
                        ByteString.Empty)
                },
                ByteString.Empty);

            TransactionInvalidException exception = await Assert.ThrowsAsync<TransactionInvalidException>(
                () => validator.PostTransaction(new ByteString(MessageSerializer.SerializeMutation(mutation)), new SignatureEvidence[0]));
            Assert.Equal("InvalidMutation", exception.Reason);
        }
Пример #42
0
        public void Mutation_Success()
        {
            Mutation mutation = new Mutation(
                binaryData[0],
                new[]
                {
                    new Record(binaryData[1], binaryData[2], binaryData[3]),
                    new Record(binaryData[4], null, binaryData[5]),
                },
                binaryData[6]);

            Assert.Equal(2, mutation.Records.Count);
            Assert.Equal(binaryData[1], mutation.Records[0].Key);
            Assert.Equal(binaryData[2], mutation.Records[0].Value);
            Assert.Equal(binaryData[3], mutation.Records[0].Version);
            Assert.Equal(binaryData[4], mutation.Records[1].Key);
            Assert.Equal(null, mutation.Records[1].Value);
            Assert.Equal(binaryData[5], mutation.Records[1].Version);
            Assert.Equal(binaryData[0], mutation.Namespace);
            Assert.Equal(binaryData[6], mutation.Metadata);
        }
Пример #43
0
    /// <summary>
    /// Atomically checks if a row/family/qualifier value matches the expected
    /// value. If it does, it adds the corresponding mutation operation for put.
    /// 
    /// @return true if the new put was executed, false otherwise
    /// </summary>
    /// <param name="tableName">name of table</param>
    /// <param name="row">row key</param>
    /// <param name="column">column name</param>
    /// <param name="value">the expected value for the column parameter, if notprovided the check is for the non-existence of thecolumn in question</param>
    /// <param name="mput">mutation for the put</param>
    /// <param name="attributes">Mutation attributes</param>
    public bool checkAndPut(byte[] tableName, byte[] row, byte[] column, byte[] value, Mutation mput, Dictionary<byte[], byte[]> attributes)
    {
      #if !SILVERLIGHT
      send_checkAndPut(tableName, row, column, value, mput, attributes);
      return recv_checkAndPut();

      #else
      var asyncResult = Begin_checkAndPut(null, null, tableName, row, column, value, mput, attributes);
      return End_checkAndPut(asyncResult);

      #endif
    }
Пример #44
0
 public void send_checkAndPut(byte[] tableName, byte[] row, byte[] column, byte[] value, Mutation mput, Dictionary<byte[], byte[]> attributes)
 #endif
 {
   oprot_.WriteMessageBegin(new TMessage("checkAndPut", TMessageType.Call, seqid_));
   checkAndPut_args args = new checkAndPut_args();
   args.TableName = tableName;
   args.Row = row;
   args.Column = column;
   args.Value = value;
   args.Mput = mput;
   args.Attributes = attributes;
   args.Write(oprot_);
   oprot_.WriteMessageEnd();
   #if SILVERLIGHT
   return oprot_.Transport.BeginFlush(callback, state);
   #else
   oprot_.Transport.Flush();
   #endif
 }
Пример #45
0
 public IAsyncResult send_checkAndPut(AsyncCallback callback, object state, byte[] tableName, byte[] row, byte[] column, byte[] value, Mutation mput, Dictionary<byte[], byte[]> attributes)
Пример #46
0
        public async Task MoveToRedemption(IList<OutboundTransaction> transactions, ByteString btcTransaction)
        {
            List<Record> records = new List<Record>();

            foreach (OutboundTransaction transaction in transactions)
            {
                // TODO: Allow double spending
                records.Add(new Record(
                    key: Encode($"/asset/{assetName}/tx/:DATA:{transaction.Version.ToString()}"),
                    value: Encode(JObject.FromObject(new { transactions = new[] { btcTransaction.ToString() } }).ToString()),
                    version: ByteString.Empty));

                records.Add(new Record(
                    key: transaction.RecordKey,
                    value: ByteString.Empty,
                    version: transaction.Version));
            }

            HttpClient client = new HttpClient();
            ByteString finalKey = Encode($"/asset/{assetName}/final/:ACC:/asset/{assetName}/");
            HttpResponseMessage getValueResponse = await client.GetAsync(new Uri(openChainUri, $"record?key={finalKey.ToString()}"));
            string stringResponse = await getValueResponse.EnsureSuccessStatusCode().Content.ReadAsStringAsync();
            ByteString finalVersion = ByteString.Parse((string)JObject.Parse(stringResponse)["version"]);
            long currentValue = ParseInt(ByteString.Parse((string)JObject.Parse(stringResponse)["value"]));

            records.Add(new Record(
                key: finalKey,
                value: Encode(currentValue + transactions.Sum(transaction => transaction.Amount)),
                version: finalVersion));

            Mutation mutation = new Mutation(Encode(this.openChainUri.ToString()), records, ByteString.Empty);

            byte[] serializedMutation = MessageSerializer.SerializeMutation(mutation);

            await SignAndSubmit(serializedMutation);
        }
Пример #47
0
        private async Task TransfertInternal(string from, string to, long amount, string asset)
        {
            var lAsset = LedgerPath.Parse(asset);
            var aFrom = new AccountKey(LedgerPath.Parse(from), lAsset);
            var aTo = new AccountKey(LedgerPath.Parse(to), lAsset);
            var accounts = await Engine.GetAccounts(new[] { aFrom, aTo });
            var adFrom = accounts[aFrom];
            var adTo = accounts[aTo];

            var rFrom = new Record(aFrom.Key.ToBinary(), LongToByteString(adFrom.Balance - amount), adFrom.Version);
            var rTo = new Record(aTo.Key.ToBinary(), LongToByteString(adTo.Balance + amount), adTo.Version);

            Mutation m = new Mutation(ByteString.Empty, new[] { rFrom, rTo }, ByteString.Empty);

            int c = System.Threading.Interlocked.Increment(ref gcounter);

            Transaction t = new Transaction(
                new ByteString(MessageSerializer.SerializeMutation(m)),
                DateTime.UtcNow,
                new ByteString(BitConverter.GetBytes(c))
            );

            await Engine.AddTransactions(new[] { new ByteString(MessageSerializer.SerializeTransaction(t)) });
            //Output.WriteLine($"{prefix} - {from} ==> {to} Success Retry : {tryCount}");
        }
 //Analyze Background Worker start. use Backgroun Worker to keep UI active while analizing.
 private void analyzeBackgroundWorker_DoWork(object sender, DoWorkEventArgs e)
 {
     hadError = false;
     _mutationList = new List<Mutation>();
     int i = 1;
     foreach (string[] s in _mutationsDetailsList)
     {
         string chrom = s[(int)XlsMinPlace.Chrom];
         int position = Convert.ToInt32(s[(int)XlsMinPlace.Position]);
         string geneName = s[(int)XlsMinPlace.GeneName];
         char refNuc = s[(int)XlsMinPlace.Ref][0];
         char varNuc = s[(int)XlsMinPlace.Var][0];
         try
         {
             Mutation tempMutation = MainBL.getMutationByDetails(chrom, position, refNuc, varNuc);
             if (tempMutation == null)
             {
                 tempMutation = new Mutation(chrom, position, geneName, refNuc, varNuc);
             }
             tempMutation.NumOfShows = Convert.ToInt16(s[(int)XlsMinPlace.NumOfShows]);
             _mutationList.Add(tempMutation);
             //_analyzeBackgroundWorker.ReportProgress(_mainForm.progressBarCounter);
             _analyzeBackgroundWorker.ReportProgress(i);
             i++;
         }
         catch (Exception)
         {
             hadError = true;
             GeneralMethods.showErrorMessageBox("Something Went Wrong, Please try Again");
             break;
         }
     }
 }
        private async Task<ByteString> AddTransaction(params Record[] records)
        {
            Mutation mutation = new Mutation(ByteString.Parse("0123"), records, ByteString.Parse("4567"));
            ByteString serializedMutation = new ByteString(MessageSerializer.SerializeMutation(mutation));
            Transaction transaction = new Transaction(
                serializedMutation,
                new DateTime(1, 2, 3, 4, 5, 6),
                ByteString.Parse("abcdef"));

            await this.Store.AddTransactions(new[] { new ByteString(MessageSerializer.SerializeTransaction(transaction)) });

            return new ByteString(MessageSerializer.ComputeHash(serializedMutation.ToByteArray()));
        }
Пример #50
0
        private async Task<byte[]> CreateTransaction(InboundTransaction transaction)
        {
            List<Record> records = new List<Record>();

            string issuanceAccount = $"/asset/{assetName}/in/{transaction.TransactionHash}/{transaction.OutputIndex}/";
            string asset = $"/asset/{assetName}/";
            string toAddress = transaction.Address;

            HttpClient client = new HttpClient();
            ByteString issuanceKey = Encode($"{issuanceAccount}:ACC:{asset}");
            HttpResponseMessage getValueResponse = await client.GetAsync(new Uri(openChainUri, $"record?key={issuanceKey.ToString()}"));
            string stringResponse = await getValueResponse.EnsureSuccessStatusCode().Content.ReadAsStringAsync();
            ByteString issuanceVersion = ByteString.Parse((string)JObject.Parse(stringResponse)["version"]);

            // The transaction has already been submitted
            if (issuanceVersion.Value.Count != 0)
                return null;

            ByteString key = Encode($"{toAddress}:ACC:{asset}");
            getValueResponse = await client.GetAsync(new Uri(openChainUri, $"record?key={key.ToString()}"));
            JObject toAccount = JObject.Parse(await getValueResponse.EnsureSuccessStatusCode().Content.ReadAsStringAsync());
            ByteString version = ByteString.Parse((string)toAccount["version"]);
            long currentToBalance = ParseInt(ByteString.Parse((string)toAccount["value"]));

            records.Add(new Record(
                key: issuanceKey,
                value: new ByteString(BitConverter.GetBytes(-transaction.Amount).Reverse().ToArray()),
                version: ByteString.Empty));

            records.Add(new Record(
                key: key,
                value: new ByteString(BitConverter.GetBytes(currentToBalance + transaction.Amount).Reverse().ToArray()),
                version: version));

            Mutation mutation = new Mutation(
                Encode(this.openChainUri.ToString()),
                records,
                ByteString.Empty);

            return MessageSerializer.SerializeMutation(mutation);
        }
 /// <summary>
 /// A convenience function which commits a mutation to datastore.
 /// Use this function to avoid a lot of boilerplate.
 /// </summary>
 /// <param name="mutation">The change to make to datastore.</param>
 /// <returns>The result of commiting the change.</returns>
 // [START commitmutation]
 private CommitResponse CommitMutation(Mutation mutation)
 {
     var commitRequest = new CommitRequest()
     {
         Mode = "NON_TRANSACTIONAL",
         Mutation = mutation
     };
     return _datastore.Datasets.Commit(commitRequest, _projectId)
         .Execute();
 }
Пример #52
0
        private ByteString AddRecord(string key)
        {
            Mutation mutation = new Mutation(
                ByteString.Empty,
                new Record[] { new Record(new ByteString(Encoding.UTF8.GetBytes(key)), ByteString.Empty, ByteString.Empty) },
                ByteString.Empty);

            Transaction transaction = new Transaction(
                new ByteString(MessageSerializer.SerializeMutation(mutation)),
                new DateTime(),
                ByteString.Empty);

            this.transactions.Add(new ByteString(MessageSerializer.SerializeTransaction(transaction)));

            return new ByteString(MessageSerializer.ComputeHash(MessageSerializer.SerializeTransaction(transaction)));
        }
        private ByteString CreateTransaction(params string[] keys)
        {
            Mutation mutation = new Mutation(
                ByteString.Empty,
                keys.Select(key => new Record(
                    new ByteString(Encoding.UTF8.GetBytes(key)),
                    ByteString.Parse("ab"),
                    ByteString.Parse("cd"))),
                ByteString.Empty);

            byte[] serializedMutation = MessageSerializer.SerializeMutation(mutation);

            Transaction transaction = new Transaction(
                new ByteString(MessageSerializer.SerializeMutation(mutation)),
                new DateTime(),
                ByteString.Empty);

            return new ByteString(MessageSerializer.SerializeTransaction(transaction));
        }
Пример #54
0
        private string GetPayingAddress(Mutation outgoingTransaction)
        {
            try
            {
                string metadata = Encoding.UTF8.GetString(outgoingTransaction.Metadata.ToByteArray(), 0, outgoingTransaction.Metadata.Value.Count);

                JObject root = JObject.Parse(metadata);
                return BitcoinAddress.Create((string)root["routing"], network).ToString();
            }
            catch (JsonReaderException)
            {
                return null;
            }
            catch (FormatException)
            {
                return null;
            }
        }
Пример #55
0
        private ByteString CreateMutation(string @namespace)
        {
            Mutation mutation = new Mutation(
                new ByteString(Encoding.UTF8.GetBytes(@namespace)),
                new Record[]
                {
                    new Record(
                        new AccountKey(LedgerPath.Parse("/account/1/"), LedgerPath.Parse("/a/")).Key.ToBinary(),
                        new ByteString(BitConverter.GetBytes(100L).Reverse()),
                        ByteString.Empty),
                    new Record(
                        new AccountKey(LedgerPath.Parse("/account/2/"), LedgerPath.Parse("/a/")).Key.ToBinary(),
                        new ByteString(BitConverter.GetBytes(100L).Reverse()),
                        ByteString.Empty),
                },
                ByteString.Empty);

            return new ByteString(MessageSerializer.SerializeMutation(mutation));
        }
Пример #56
0
 public IAsyncResult Begin_checkAndPut(AsyncCallback callback, object state, byte[] tableName, byte[] row, byte[] column, byte[] value, Mutation mput, Dictionary<byte[], byte[]> attributes)
 {
   return send_checkAndPut(callback, state, tableName, row, column, value, mput, attributes);
 }
Пример #57
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.String) {
           Row = iprot.ReadBinary();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 2:
         if (field.Type == TType.List) {
           {
             Mutations = new List<Mutation>();
             TList _list0 = iprot.ReadListBegin();
             for( int _i1 = 0; _i1 < _list0.Count; ++_i1)
             {
               Mutation _elem2 = new Mutation();
               _elem2 = new Mutation();
               _elem2.Read(iprot);
               Mutations.Add(_elem2);
             }
             iprot.ReadListEnd();
           }
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       default: 
         TProtocolUtil.Skip(iprot, field.Type);
         break;
     }
     iprot.ReadFieldEnd();
   }
   iprot.ReadStructEnd();
 }
 protected virtual Task AddTransaction(long transactionId, byte[] transactionHash, Mutation mutation)
 {
     return Task.FromResult(0);
 }
Пример #59
0
        private async Task<ByteString> AddRecords(ByteString version, ByteString value, params string[] keys)
        {
            Mutation mutation = new Mutation(
                ByteString.Empty,
                keys.Select(key => new Record(
                    new ByteString(Encoding.UTF8.GetBytes(key)),
                    value,
                    version)),
                ByteString.Empty);

            byte[] serializedMutation = MessageSerializer.SerializeMutation(mutation);

            Transaction transaction = new Transaction(
                new ByteString(MessageSerializer.SerializeMutation(mutation)),
                new DateTime(),
                ByteString.Empty);

            await Engine.AddTransactions(new[] { new ByteString(MessageSerializer.SerializeTransaction(transaction)) });

            return new ByteString(MessageSerializer.ComputeHash(serializedMutation));
        }
        private async Task UpdateAccounts(Mutation mutation, byte[] transactionHash)
        {
            foreach (Record record in mutation.Records)
            {
                if (record.Value == null)
                {
                    // Read the record and make sure it corresponds to the one supplied
                    IReadOnlyList<byte[]> versions = await ExecuteAsync(@"
                            SELECT  Version
                            FROM    Records
                            WHERE   Key = @key",
                        reader => (byte[])reader.GetValue(0),
                        new Dictionary<string, object>()
                        {
                            ["@key"] = record.Key.ToByteArray()
                        });

                    if (versions.Count == 0)
                    {
                        if (!record.Version.Equals(ByteString.Empty))
                            throw new ConcurrentMutationException(record);
                    }
                    else
                    {
                        if (!new ByteString(versions[0]).Equals(record.Version))
                            throw new ConcurrentMutationException(record);
                    }
                }
                else
                {
                    if (!record.Version.Equals(ByteString.Empty))
                    {
                        // Update existing account
                        int count = await ExecuteAsync(@"
                                UPDATE  Records
                                SET     Value = @value, Version = @version
                                WHERE   Key = @key AND Version = @currentVersion",
                            new Dictionary<string, object>()
                            {
                                ["@key"] = record.Key.ToByteArray(),
                                ["@value"] = record.Value.ToByteArray(),
                                ["@version"] = transactionHash,
                                ["@currentVersion"] = record.Version.ToByteArray()
                            });

                        if (count == 0)
                            throw new ConcurrentMutationException(record);
                    }
                    else
                    {
                        // Create a new record
                        try
                        {
                            await ExecuteAsync(@"
                                    INSERT INTO Records
                                    (Key, Value, Version)
                                    VALUES (@key, @value, @version)",
                                new Dictionary<string, object>()
                                {
                                    ["@key"] = record.Key.ToByteArray(),
                                    ["@value"] = record.Value.ToByteArray(),
                                    ["@version"] = transactionHash
                                });
                        }
                        catch (SqliteException exception) when (exception.Message.Contains("UNIQUE constraint failed: Records.Key"))
                        {
                            throw new ConcurrentMutationException(record);
                        }
                    }
                }
            }
        }