Inheritance: IDataBackend
示例#1
0
        public void Start(string use_backend = "sqlite")
        {
            tmpPath = "/tmp/rainy-test-data/";
            Directory.CreateDirectory(tmpPath);
            DbConfig.SetSqliteFile(Path.Combine(tmpPath, "rainy-test.db"));
            // tmpPath = Path.GetTempPath () + Path.GetRandomFileName ();

            IDataBackend backend;

            if (use_backend == "sqlite")
            {
                backend = new DatabaseBackend(tmpPath, credentialsVerifier);
                DbConfig.CreateSchema(reset: true);
                using (var c = DbConfig.GetConnection()) {
                    c.Insert <DBUser>(new DBUser()
                    {
                        Username = TEST_USER
                    });
                }
            }
            else
            {
                backend = new RainyFileSystemBackend(tmpPath, credentialsVerifier);
            }

            rainyServer = new RainyStandaloneServer(backend, RainyListenUrl);

            rainyServer.Start();
        }
示例#2
0
        private void WireupGenericTestClasses(Funq.Container container)
        {
            container.Register <IAuthenticator> (c => {
                var factory = c.Resolve <IDbConnectionFactory> ();
                var dbauth  = new DbAuthenticator(factory);
                //var dbauth = new DbTestAuthenticator ();

                var test_user = new DBUser {
                    Username    = RainyTestServer.TEST_USER,
                    IsActivated = true,
                    IsVerified  = true
                };
                test_user.CreateCryptoFields(RainyTestServer.TEST_PASS);

                // insert a dummy testuser
                using (var db = factory.OpenDbConnection()) {
                    db.InsertParam <DBUser> (test_user);
                }

                return(dbauth);
            });

            container.Register <IAdminAuthenticator> (c => {
                var admin_auth = new DummyAdminAuthenticator(ADMIN_TEST_PASS);
                return((IAdminAuthenticator)admin_auth);
            });

            RegisterStorageFactory(container, false);

            container.Register <IDataBackend> (c => {
                var conn_factory    = c.Resolve <IDbConnectionFactory> ();
                var storage_factory = c.Resolve <DbStorageFactory> ();
                var auth            = c.Resolve <IAuthenticator> ();
                var handler         = c.Resolve <OAuthHandler> ();
                return(new DatabaseBackend(conn_factory, storage_factory, auth, handler));
            });

            container.Register <OAuthHandler> (c => {
                var auth    = c.Resolve <IAuthenticator> ();
                var factory = c.Resolve <IDbConnectionFactory> ();
//				ITokenRepository<AccessToken> access_tokens = new SimpleTokenRepository<AccessToken> ();
//				ITokenRepository<RequestToken> request_tokens = new SimpleTokenRepository<RequestToken> ();
                ITokenRepository <AccessToken> access_tokens   = new DbAccessTokenRepository <AccessToken> (factory);
                ITokenRepository <RequestToken> request_tokens = new DbRequestTokenRepository <RequestToken> (factory);
                ITokenStore token_store = new RainyTokenStore(access_tokens, request_tokens);
                OAuthHandler handler    = new OAuthHandler(auth, access_tokens, request_tokens, token_store);
                return(handler);
            });

            var connFactory = container.Resolve <IDbConnectionFactory> ();

            DatabaseBackend.CreateSchema(connFactory, true);

            // HACK so the user is inserted when a fixture SetUp is run
            container.Resolve <IAuthenticator> ();
        }
示例#3
0
文件: Main.cs 项目: gmstrbytes/Rainy
        // This is the "Composition Root" in the IoC pattern that wires all
        // our objects/implementations up, based on a given configuration.
        // config sanity checks SHOULD NOT go here

        private static void ComposeObjectGraph(Funq.Container container)
        {
            var config = Config.Global;

            container.Register <SqliteConfig> (c => new SqliteConfig {
                File = Path.Combine(config.DataPath, "rainy.db")
            });

            container.Register <PostgreConfig> (c => {
                dynamic txt_conf = config.Postgre;
                var psql_conf    = new PostgreConfig();
                if (!string.IsNullOrEmpty(txt_conf.Username))
                {
                    psql_conf.Username = txt_conf.Username;
                }
                if (!string.IsNullOrEmpty(txt_conf.Password))
                {
                    psql_conf.Password = txt_conf.Password;
                }
                if (!string.IsNullOrEmpty(txt_conf.Database))
                {
                    psql_conf.Database = txt_conf.Database;
                }
                if (!string.IsNullOrEmpty(txt_conf.Host))
                {
                    psql_conf.Host = txt_conf.Host;
                }
                if (txt_conf.Port > 0)
                {
                    psql_conf.Port = (uint)txt_conf.Port;
                }

                return(psql_conf);
            });

            if (config.Backend == "xml")
            {
                // use username/password pairs from the config file
                container.Register <IAuthenticator> (c => {
                    return(new ConfigFileAuthenticator(config.User));
                });

                // we store notes in XML files in the DataPath
                container.Register <IDataBackend> (c => {
                    var auth          = c.Resolve <IAuthenticator> ();
                    var factory       = c.Resolve <IDbConnectionFactory> ();
                    var oauth_handler = c.Resolve <OAuthHandler> ();
                    return(new FileSystemBackend(config.DataPath, factory, auth, oauth_handler, false));
                });
            }
            else
            {
                // database based backends
                switch ((string)config.Backend)
                {
                case "sqlite":
                    container.Register <IDbConnectionFactory> (c => {
                        var conf = container.Resolve <SqliteConfig> ();
                        var connection_string = conf.ConnectionString;
                        var factory           = new OrmLiteConnectionFactory(connection_string, SqliteDialect.Provider);

                        if (!File.Exists(conf.File))
                        {
                            DatabaseBackend.CreateSchema(factory);
                        }

                        return((IDbConnectionFactory)factory);
                    });
                    break;

                case "postgre":
                    container.Register <IDbConnectionFactory> (c => {
                        var connection_string = container.Resolve <PostgreConfig> ().ConnectionString;
                        var factory           = new OrmLiteConnectionFactory(connection_string, PostgreSqlDialect.Provider);
                        DatabaseBackend.CreateSchema(factory);
                        return(factory);
                    });
                    break;
                }

                container.Register <IAuthenticator> (c => {
                    var factory = c.Resolve <IDbConnectionFactory> ();
//					var sfactory = new OrmLiteConnectionFactory ();
                    var dbauth = new DbAuthenticator(factory);
                    //var dbauth = new ConfigFileAuthenticator (Config.Global.Users);

                    // we have to make sure users from the config file exist with the configured password
                    // in the db
                    // TODO delete old users? or restrict to webinterface?
                    if (dbauth is ConfigFileAuthenticator)
                    {
                        foreach (dynamic user in Config.Global.Users)
                        {
                            string username = user.Username;
                            string password = user.Password;
                            using (var db = factory.OpenDbConnection()) {
                                var db_user = db.FirstOrDefault <DBUser> (u => u.Username == username);
                                if (db_user != null)
                                {
                                    var need_update = db_user.UpdatePassword(password);
                                    if (need_update)
                                    {
                                        db.UpdateOnly(new DBUser {
                                            PasswordHash = db_user.PasswordHash
                                        }, u => new { u.PasswordHash }, (DBUser p) => p.Username == username);
                                    }
                                }
                                else
                                {
                                    // create the user in the db
                                    var new_user      = new DBUser();
                                    new_user.Username = username;
                                    new_user.CreateCryptoFields(password);
                                    new_user.UpdatePassword(password);
                                    db.Insert <DBUser> (new_user);
                                }
                            }
                        }
                    }
                    return(dbauth);
                });
//
                container.Register <IAdminAuthenticator> (c => {
                    var auth = new ConfigFileAdminAuthenticator();
                    return(auth);
                });

                container.Register <OAuthHandler> (c => {
                    var auth    = c.Resolve <IAuthenticator> ();
                    var factory = c.Resolve <IDbConnectionFactory> ();
                    //				ITokenRepository<AccessToken> access_tokens = new SimpleTokenRepository<AccessToken> ();
                    //				ITokenRepository<RequestToken> request_tokens = new SimpleTokenRepository<RequestToken> ();
                    ITokenRepository <AccessToken> access_tokens   = new DbAccessTokenRepository <AccessToken> (factory);
                    ITokenRepository <RequestToken> request_tokens = new DbRequestTokenRepository <RequestToken> (factory);
                    ITokenStore token_store = new RainyTokenStore(access_tokens, request_tokens);
                    OAuthHandler handler    = new OAuthHandler(auth, access_tokens, request_tokens, token_store);
                    return(handler);
                });

                container.Register <DbStorageFactory> (c => {
                    var conn_factory    = c.Resolve <IDbConnectionFactory> ();
                    bool use_encryption = (bool)Config.Global.UseNoteEncryption;

                    var storage_factory = new DbStorageFactory(conn_factory, use_encryption, use_history: true);
                    return(storage_factory);
                });

                container.Register <IDataBackend> (c => {
                    var conn_factory    = c.Resolve <IDbConnectionFactory> ();
                    var storage_factory = c.Resolve <DbStorageFactory> ();
                    var handler         = c.Resolve <OAuthHandler> ();
                    var auth            = c.Resolve <IAuthenticator> ();
                    return(new DatabaseBackend(conn_factory, storage_factory, auth, handler));
                });

/*				container.Register<OAuthHandler> (c => {
 *                                      var factory = c.Resolve<IDbConnectionFactory> ();
 *                                      var access_token_repo = new DbAccessTokenRepository<AccessToken> (factory);
 *                                      var request_token_repo = new SimpleTokenRepository<RequestToken> ();
 *                                      var auth = c.Resolve<IAuthenticator> ();
 *                                      var token_store = new Rainy.OAuth.SimpleStore.SimpleTokenStore (access_token_repo, request_token_repo);
 *
 *                                      var handler = new OAuthHandler (auth, token_store);
 *                                      return handler;
 *                              });
 */
                if (config.Development == true)
                {
                    AddDummyUserIfRequired(container);
                }
            }
        }
示例#4
0
        public void Start(string use_backend = "sqlite")
        {
            tmpPath = "/tmp/rainy-test-data/";
            Directory.CreateDirectory (tmpPath);
            DbConfig.SetSqliteFile (Path.Combine (tmpPath, "rainy-test.db"));
            // tmpPath = Path.GetTempPath () + Path.GetRandomFileName ();

            IDataBackend backend;
            if (use_backend == "sqlite") {
                backend = new DatabaseBackend (tmpPath, credentialsVerifier);
                DbConfig.CreateSchema(reset: true);
                using (var c = DbConfig.GetConnection ()) {
                    c.Insert<DBUser>(new DBUser() { Username = TEST_USER });
                }
            }
            else
                backend = new RainyFileSystemBackend (tmpPath, credentialsVerifier);

            rainyServer = new RainyStandaloneServer (backend, RainyListenUrl);

            rainyServer.Start ();
        }
示例#5
0
        public static void Main(string[] args)
        {
            // parse command line arguments
            string config_file = "settings.conf";
            string cert_file = null, pvk_file = null;

            int  loglevel     = 0;
            bool show_help    = false;
            bool open_browser = false;

            var p = new OptionSet()
            {
                { "c|config=", "use config file",
                  (string file) => config_file = file },
                { "v", "increase log level, where -vvvv is highest",
                  v => { if (v != null)
                         {
                             ++loglevel;
                         }
                  } },
                { "h|help", "show this message and exit",
                  v => show_help = v != null },
                { "cert=", "use this certificate for SSL",
                  (string file) => cert_file = file },
                { "pvk=", "use private key for certSSL",
                  (string file2) => pvk_file = file2 },

                //{ "b|nobrowser",  "do not open browser window upon start",
                //	v => { if (v != null) open_browser = false; } },
            };

            p.Parse(args);

            if (show_help)
            {
                p.WriteOptionDescriptions(Console.Out);
                return;
            }

            if (!File.Exists(config_file))
            {
                Console.WriteLine("Could not find a configuration file (try the -c flag)!");
                return;
            }

            // set the configuration from the specified file
            Config.Global = Config.ApplyJsonFromPath(config_file);

            DataPath = Config.Global.DataPath;
            if (string.IsNullOrEmpty(DataPath))
            {
                DataPath = Directory.GetCurrentDirectory();
            }
            else
            {
                if (!Directory.Exists(DataPath))
                {
                    Directory.CreateDirectory(DataPath);
                }
            }

            var sqlite_file = Path.Combine(DataPath, "rainy.db");

            DbConfig.SetSqliteFile(sqlite_file);

            SetupLogging(loglevel);
            logger = LogManager.GetLogger("Main");

            string listen_url = Config.Global.ListenUrl;

            if (string.IsNullOrEmpty(listen_url))
            {
                listen_url = "https://localhost:443/";
                logger.InfoFormat("no ListenUrl set in the settings.conf, using the default: {0}",
                                  listen_url);
            }
            // servicestack expects trailing slash, else error is thrown
            if (!listen_url.EndsWith("/"))
            {
                listen_url += "/";
            }

            ConfigureSslCerts(listen_url, cert_file, pvk_file);

            // determine and setup data backend
            string backend = Config.Global.Backend;

            IDataBackend data_backend;
            // simply use user/password list from config for authentication
            CredentialsVerifier config_authenticator = (username, password) => {
                // call the authenticater callback
                if (string.IsNullOrEmpty(username) || string.IsNullOrEmpty(password))
                {
                    return(false);
                }

                foreach (dynamic credentials in Config.Global.Users)
                {
                    if (credentials.Username == username && credentials.Password == password)
                    {
                        return(true);
                    }
                }
                return(false);
            };

            // by default we use the filesystem backend
            if (string.IsNullOrEmpty(backend))
            {
                backend = "filesystem";
            }

            if (backend == "sqlite")
            {
                /* if (string.IsNullOrEmpty (Config.Global.AdminPassword)) {
                 *      Console.WriteLine ("FATAL: Field 'AdminPassword' in the settings config may not " +
                 *                         "be empty when using the sqlite backend");
                 *      return;
                 * } */
                data_backend = new DatabaseBackend(DataPath, config_authenticator);
            }
            else
            {
                data_backend = new RainyFileSystemBackend(DataPath, config_authenticator);
            }

            string admin_ui_url = listen_url.Replace("*", "localhost");

            if (open_browser)
            {
                admin_ui_url += "admin/#?admin_pw=" + Config.Global.AdminPassword;
            }

            using (var listener = new RainyStandaloneServer(data_backend, listen_url)) {
                listener.Start();
                Uptime = DateTime.UtcNow;

                if (open_browser)
                {
                    Process.Start(admin_ui_url);
                }

                if (Environment.OSVersion.Platform != PlatformID.Unix &&
                    Environment.OSVersion.Platform != PlatformID.MacOSX)
                {
                    // we run on windows, can't wait for unix signals
                    Console.WriteLine("Press return to stop Rainy");
                    Console.ReadLine();
                    Environment.Exit(0);
                }
                else
                {
                    // we run UNIX
                    UnixSignal [] signals = new UnixSignal[] {
                        new UnixSignal(Signum.SIGINT),
                        new UnixSignal(Signum.SIGTERM),
                    };

                    // Wait for a unix signal
                    for (bool exit = false; !exit;)
                    {
                        int id = UnixSignal.WaitAny(signals);

                        if (id >= 0 && id < signals.Length)
                        {
                            if (signals[id].IsSet)
                            {
                                exit = true;
                            }
                            logger.Debug("received signal, exiting");
                        }
                    }
                }
            }
        }
示例#6
0
        public static void StartNewServer(string use_backend = "sqlite")
        {
            tmpPath = "/tmp/rainy-test-data/";
            if (Directory.Exists (tmpPath)) {
                Directory.Delete (tmpPath, true);
            }
            Directory.CreateDirectory (tmpPath);
            DbConfig.SetSqliteFile (Path.Combine (tmpPath, "rainy-test.db"));
            // tmpPath = Path.GetTempPath () + Path.GetRandomFileName ();

            // for debugging, we only use a simple single user authentication
            CredentialsVerifier debug_authenticator = (user,pass) => {
                if (user == TEST_USER  && pass == TEST_PASS) return true;
                else return false;
            };

            IDataBackend backend;
            if (use_backend == "sqlite")
                backend = new DatabaseBackend (tmpPath, auth: debug_authenticator, reset: true);
            else
                backend = new RainyFileSystemBackend (tmpPath, debug_authenticator);

            rainyServer = new RainyStandaloneServer (backend, RainyListenUrl, test_server: true);

            rainyServer.Start ();
        }
示例#7
0
文件: Main.cs 项目: BooTeK/Rainy
        public static void Main(string[] args)
        {
            // parse command line arguments
            string config_file = "settings.conf";
            string cert_file = null, pvk_file = null;

            int loglevel = 0;
            bool show_help = false;
            bool open_browser = false;

            var p = new OptionSet () {
                { "c|config=", "use config file",
                    (string file) => config_file = file },
                { "v", "increase log level, where -vvvv is highest",
                    v => { if (v != null) ++loglevel; } },
                { "h|help",  "show this message and exit",
                    v => show_help = v != null },
                { "cert=",  "use this certificate for SSL",
                    (string file) => cert_file = file },
                { "pvk=",  "use private key for certSSL",
                    (string file2) => pvk_file = file2 },

                //{ "b|nobrowser",  "do not open browser window upon start",
                //	v => { if (v != null) open_browser = false; } },
            };
            p.Parse (args);

            if (show_help) {
                p.WriteOptionDescriptions (Console.Out);
                return;
            }

            if (!File.Exists (config_file)) {
                Console.WriteLine ("Could not find a configuration file (try the -c flag)!");
                return;
            }

            // set the configuration from the specified file
            Config.Global = Config.ApplyJsonFromPath (config_file);

            DataPath = Config.Global.DataPath;
            if (string.IsNullOrEmpty (DataPath)) {
                DataPath = Directory.GetCurrentDirectory ();
            } else {
                if (!Directory.Exists (DataPath))
                    Directory.CreateDirectory (DataPath);
            }

            var sqlite_file = Path.Combine (DataPath, "rainy.db");
            DbConfig.SetSqliteFile (sqlite_file);

            SetupLogging (loglevel);
            logger = LogManager.GetLogger ("Main");

            string listen_url = Config.Global.ListenUrl;
            if (string.IsNullOrEmpty (listen_url)) {
                listen_url = "https://localhost:443/";
                logger.InfoFormat ("no ListenUrl set in the settings.conf, using the default: {0}",
                                   listen_url);
            }
            // servicestack expects trailing slash, else error is thrown
            if (!listen_url.EndsWith ("/")) listen_url += "/";

            ConfigureSslCerts (listen_url, cert_file, pvk_file);

            // determine and setup data backend
            string backend = Config.Global.Backend;

            IDataBackend data_backend;
            // simply use user/password list from config for authentication
            CredentialsVerifier config_authenticator = (username, password) => {
                // call the authenticater callback
                if (string.IsNullOrEmpty (username) || string.IsNullOrEmpty (password))
                return false;

                foreach (dynamic credentials in Config.Global.Users) {
                    if (credentials.Username == username && credentials.Password == password)
                        return true;
                }
                return false;
            };
            // by default we use the filesystem backend
            if (string.IsNullOrEmpty (backend)) {
                backend = "filesystem";
            }

            if (backend == "sqlite") {

                /* if (string.IsNullOrEmpty (Config.Global.AdminPassword)) {
                    Console.WriteLine ("FATAL: Field 'AdminPassword' in the settings config may not " +
                                       "be empty when using the sqlite backend");
                    return;
                } */
                data_backend = new DatabaseBackend (DataPath, config_authenticator);
            } else {

                data_backend = new RainyFileSystemBackend (DataPath, config_authenticator);
            }

            string admin_ui_url = listen_url.Replace ("*", "localhost");

            if (open_browser) {
                admin_ui_url += "admin/#?admin_pw=" + Config.Global.AdminPassword;
            }

            using (var listener = new RainyStandaloneServer (data_backend, listen_url)) {

                listener.Start ();
                Uptime = DateTime.UtcNow;

                if (open_browser) {
                    Process.Start (admin_ui_url);
                }

                if (Environment.OSVersion.Platform != PlatformID.Unix &&
                    Environment.OSVersion.Platform != PlatformID.MacOSX) {
                    // we run on windows, can't wait for unix signals
                    Console.WriteLine ("Press return to stop Rainy");
                    Console.ReadLine ();
                    Environment.Exit(0);

                } else {
                    // we run UNIX
                    UnixSignal [] signals = new UnixSignal[] {
                        new UnixSignal(Signum.SIGINT),
                        new UnixSignal(Signum.SIGTERM),
                    };

                    // Wait for a unix signal
                    for (bool exit = false; !exit; )
                    {
                        int id = UnixSignal.WaitAny(signals);

                        if (id >= 0 && id < signals.Length)
                        {
                            if (signals[id].IsSet) exit = true;
                            logger.Debug ("received signal, exiting");
                        }
                    }
                }
            }
        }