public async Task StoreAsync(string key, Token value)
 {
     await TryWithAwaitInCatch.ExecuteAndHandleErrorAsync(
         async() =>
     {
         await ResilientSessionContainer.EstablishSessionAsync();
         var flat = new FlattenedTokenHandle(key, value);
         await ResilientSessionContainer.ResilientSession.CreateTokenHandleAsync(flat);
     },
         async (ex) => ResilientSessionContainer.HandleCassandraException <Task>(ex));
 }
        public async Task TestCreateTokenHandleAsync()
        {
            var dao = new IdentityServer3CassandraDao();
            await dao.EstablishConnectionAsync();

            int i      = 0;
            var claims = new List <Claim>()
            {
                new Claim("Type 0:" + i, "Value 0:" + i),
                new Claim("Type 1:" + i, "Value 1:" + i)
            };
            var json = JsonConvert.SerializeObject(claims);

            var insert = await CassandraTestHelper.InsertTestData_Clients(1);

            var flat = new FlattenedTokenHandle
            {
                Key          = Guid.NewGuid().ToString(),
                Audience     = "Audience:" + i,
                Claims       = JsonConvert.SerializeObject(claims),
                ClientId     = insert[0].ClientId,
                CreationTime = DateTimeOffset.UtcNow,
                Expires      = DateTimeOffset.UtcNow,
                Issuer       = "Issuer:" + i,
                Lifetime     = 1,
                SubjectId    = "SubjectId:" + i,
                Type         = "Type:" + i,
                Version      = 1
            };
            IClientStore      cs  = new ClientStore();
            ITokenHandleStore ths = new TokenHandleStore();
            var result            = await dao.CreateTokenHandleAsync(flat);

            var result_of_find = await dao.FindTokenByKey(flat.Key, cs);

            Token tt = result_of_find;

            Assert.AreEqual(flat.ClientId, result_of_find.ClientId);

            var newKey = Guid.NewGuid().ToString();
            await ths.StoreAsync(newKey, tt);

            result_of_find = await ths.GetAsync(newKey);

            Assert.AreEqual(flat.ClientId, result_of_find.ClientId);

            await ths.RemoveAsync(newKey);

            result_of_find = await ths.GetAsync(newKey);

            Assert.AreEqual(result_of_find, null);
        }
Esempio n. 3
0
 public async Task <bool> CreateTokenHandleAsync(FlattenedTokenHandle tokenHandle,
                                                 CancellationToken cancellationToken = default(CancellationToken))
 {
     try
     {
         MyMappings.Init();
         var list = new List <FlattenedTokenHandle> {
             tokenHandle
         };
         return(await CreateManyTokenHandleAsync(list, cancellationToken));
     }
     catch (Exception e)
     {
         return(false);
     }
 }
        public static async Task <List <FlattenedTokenHandle> > InsertTestData_Tokens(int count = 1)
        {
            var dao = new IdentityServer3CassandraDao();
            await dao.EstablishConnectionAsync();

            var insertClients = await CassandraTestHelper.InsertTestData_Clients(1); // only add one client

            // we are going to associate a bunch of tokens to this one client

            var client    = insertClients[0];
            var subjectId = Guid.NewGuid().ToString();
            List <FlattenedTokenHandle> result = new List <FlattenedTokenHandle>();

            for (int i = 0; i < count; ++i)
            {
                var claims = new List <Claim>()
                {
                    new Claim(Constants.ClaimTypes.Subject, subjectId),
                    new Claim(Constants.ClaimTypes.Name, "Name:" + i)
                };
                var json = JsonConvert.SerializeObject(claims);

                var flat = new FlattenedTokenHandle
                {
                    Key          = Guid.NewGuid().ToString(),
                    Audience     = "Audience:" + i,
                    Claims       = JsonConvert.SerializeObject(claims),
                    ClientId     = client.ClientId,
                    CreationTime = DateTimeOffset.UtcNow,
                    Expires      = DateTimeOffset.UtcNow,
                    Issuer       = "Issuer:" + i,
                    Lifetime     = 1,
                    SubjectId    = subjectId,
                    Type         = "Type:" + i,
                    Version      = 1
                };

                result.Add(flat);
            }
            await dao.CreateManyTokenHandleAsync(result);

            return(result);
        }