예제 #1
0
        /// <summary>
        /// Update the session
        /// </summary>
        /// <param name="configuration">The session store configuration</param>
        /// <param name="id">The Id of the session</param>
        /// <param name="session">The session to be persisted</param>
        /// <exception cref="InvalidOperationException">If the update errors</exception>
        public static async Task UpdateSession(RethinkDbSessionConfiguration configuration, string id, ISession session)
        {
            var sessionDocument = new RethinkDbSessionDocument
            {
                Id           = id,
                LastAccessed = DateTime.Now,
                Data         = session.ToDictionary(item => item.Key, item => item.Value)
            };

            Func <Get, Update> update = get => {
                if (configuration.UseRollingSessions)
                {
                    return(get.Update(new
                    {
                        LastAccessed = sessionDocument.LastAccessed,
                        Data = sessionDocument.Data
                    }));
                }
                else
                {
                    return(get.Update(new { Data = sessionDocument.Data }));
                }
            };

            var result = await update(Table(configuration).Get(id)).RunResultAsync(configuration.Connection);

            if (0 != result.Errors)
            {
                throw new InvalidOperationException(String.Format("Unable to save data for session Id {0}: {1}", id,
                                                                  result.FirstError));
            }
        }
예제 #2
0
        /// <summary>
        /// Initialise and add RethinkDB session storage hooks to the application pipeline
        /// </summary>
        /// <param name="pipelines">Application pipelines</param>
        /// <param name="connection">The RethinkDB connection to use for session storage</param>
        /// <param name="cryptographyConfiguration">Cryptography configuration</param>
        public static void Enable(IPipelines pipelines, IConnection connection,
                                  CryptographyConfiguration cryptographyConfiguration)
        {
            var rethinkDbSessionConfiguration = new RethinkDbSessionConfiguration(connection, cryptographyConfiguration)
            {
                Serializer = new DefaultObjectSerializer()
            };

            Enable(pipelines, rethinkDbSessionConfiguration);
        }
예제 #3
0
        /// <summary>
        /// Update the last accessed date/time for a session
        /// </summary>
        /// <param name="configuration">The session store configuration</param>
        /// <param name="id">The Id of the session to be updated</param>
        /// <exception cref="InvalidOperationException">If there is an error updating the session</exception>
        public static async Task UpdateLastAccessed(RethinkDbSessionConfiguration configuration, string id)
        {
            var result = await Table(configuration).Get(id).Update(new { LastAccessed = DateTime.Now })
                         .RunResultAsync(configuration.Connection);

            if (0 != result.Errors)
            {
                throw new InvalidOperationException(String.Format("Could not update last access for session Id {0}: {1}",
                                                                  id, result.FirstError));
            }
        }
예제 #4
0
        /// <summary>
        /// Expire (delete) old sessions
        /// </summary>
        /// <param name="configuration">The session store configuration</param>
        /// <exception cref="InvalidOperationException">If there is an error deleting old sessions</exception>
        public static async Task ExpireSessions(RethinkDbSessionConfiguration configuration)
        {
            var result = await Table(configuration).Between(R.Minval(), DateTime.Now - configuration.Expiry)
                         .OptArg("index", nameof(RethinkDbSessionDocument.LastAccessed))
                         .Delete()
                         .RunResultAsync(configuration.Connection);

            if (0 != result.Errors)
            {
                throw new InvalidOperationException(String.Concat("Error expiring sessions: ", result.FirstError));
            }
        }
예제 #5
0
        /// <summary>
        /// Initialise and add RethinkDB session storage hooks to the application pipeline
        /// </summary>
        /// <param name="pipelines">Application pipelines</param>
        /// <param name="configuration">Cookie based sessions configuration.</param>
        public static void Enable(IPipelines pipelines, RethinkDbSessionConfiguration configuration)
        {
            if (pipelines == null)
            {
                throw new ArgumentNullException("pipelines");
            }

            var sessionStore = new RethinkDbSessions(configuration);

            pipelines.BeforeRequest.AddItemToStartOfPipeline(ctx => LoadSession(ctx, sessionStore));
            pipelines.AfterRequest.AddItemToEndOfPipeline(ctx => SaveSession(ctx, sessionStore));
        }
예제 #6
0
        /// <summary>
        /// Create a new session
        /// </summary>
        /// <param name="configuration">The session store configuration</param>
        /// <param name="id">The Id of the session to create</param>
        /// <exception cref="InvalidOperationException">If the session cannot be created</exception>
        public static async Task NewSession(RethinkDbSessionConfiguration configuration, string id)
        {
            var result = await Table(configuration).Insert(new RethinkDbSessionDocument
            {
                Id           = id,
                LastAccessed = DateTime.Now,
                Data         = new Dictionary <string, object>()
            }).RunResultAsync(configuration.Connection);

            if (0 != result.Errors)
            {
                throw new InvalidOperationException(String.Format("Could not create new session Id {0}: {1}", id,
                                                                  result.FirstError));
            }
        }
예제 #7
0
        /// <summary>
        /// Initializes a new instance of the <see cref="RethinkDbSessions"/> class.
        /// </summary>
        /// <param name="configuration">Cookie based sessions configuration.</param>
        public RethinkDbSessions(RethinkDbSessionConfiguration configuration)
        {
            if (configuration == null)
            {
                throw new ArgumentNullException("configuration");
            }

            if (!configuration.IsValid)
            {
                throw new ArgumentException("Configuration is invalid", "configuration");
            }
            this.currentConfiguration = configuration;

            this.Await(RethinkDbSessionStore.SetUp(this.currentConfiguration));
        }
예제 #8
0
        /// <summary>
        /// Retrieve a session from the store
        /// </summary>
        /// <param name="configuration">The session store configuration</param>
        /// <param name="id">The Id of the session to retrieve</param>
        /// <returns>The session (null if a session with the given Id is not found)</returns>
        public static async Task <ISession> RetrieveSession(RethinkDbSessionConfiguration configuration, string id)
        {
            var doc = await Table(configuration).Get(id)
                      .RunAtomAsync <RethinkDbSessionDocument>(configuration.Connection);

            if (null == doc)
            {
                return(null);
            }

            var session = new Session(doc.Data);

            session["_id"] = id;

            return(session);
        }
예제 #9
0
        /// <summary>
        /// Create the database if it does not exist
        /// </summary>
        /// <param name="configuration">The session store configuration</param>
        /// <exception cref="InvalidOperationException">If there is a problem creating the database</exception>
        private static async Task DatabaseCheck(RethinkDbSessionConfiguration configuration)
        {
            var databases = await R.DbList().RunAtomAsync <List <string> >(configuration.Connection);

            if (!databases.Contains(configuration.Database))
            {
                var result = await R.DbCreate(configuration.Database).RunResultAsync(configuration.Connection);

                if (0 != result.Errors)
                {
                    throw new InvalidOperationException(String.Format(
                                                            "Could not create RethinkDB session store database {0}: {1}", configuration.Database,
                                                            result.FirstError));
                }
            }
        }
예제 #10
0
        /// <summary>
        /// Create the index on the last accessed date/time if it does not exist
        /// </summary>
        /// <param name="configuration">The session store configuration</param>
        /// <exception cref="InvalidOperationException">If there is a problem creating the index</exception>
        private static async Task IndexCheck(RethinkDbSessionConfiguration configuration)
        {
            var indexName = nameof(RethinkDbSessionDocument.LastAccessed);
            var indexes   = await Table(configuration).IndexList()
                            .RunAtomAsync <List <string> >(configuration.Connection);

            if (!indexes.Contains(indexName))
            {
                var result = await R.Db(configuration.Database).Table(configuration.Table).IndexCreate(indexName)
                             .RunResultAsync(configuration.Connection);

                if (0 != result.Errors)
                {
                    throw new InvalidOperationException(String.Format(
                                                            "Could not create last accessed index on RethinkDB session store table {0}.{1}: {2}",
                                                            configuration.Database, configuration.Table, result.FirstError));
                }
            }
        }
예제 #11
0
 /// <summary>
 /// Shorthand to get the session table
 /// </summary>
 /// <param name="configuration">The session store configuration</param>
 /// <returns>The table reference for further manipulation</returns>
 private static Table Table(RethinkDbSessionConfiguration configuration) =>
 R.Db(configuration.Database).Table(configuration.Table);
예제 #12
0
 /// <summary>
 /// Set up the session store; ensures the database, table, and required indexes exist
 /// </summary>
 /// <param name="configuration">The session store configuration</param>
 public static async Task SetUp(RethinkDbSessionConfiguration configuration)
 {
     await DatabaseCheck(configuration);
     await TableCheck(configuration);
 }