public static void Main(string[] args) { CouchbaseLiteServiceListener listener = new CouchbaseLiteTcpListener(Manager.SharedInstance, port); listener.Start(); Console.ReadKey(true); listener.Stop(); }
public static void Main(string[] args) { CouchbaseLiteServiceListener listener = new CouchbaseLiteTcpListener(Manager.SharedInstance, port); listener.SetPasswords(new Dictionary<string, string> { { "jim", "borden" } }); listener.Start(); Console.ReadKey(true); listener.Stop(); }
static void Main(string[] args) { CouchbaseLiteServiceListener listener = new CouchbaseLiteTcpListener(Manager.SharedInstance, listenerPort); listener.Start(); Console.WriteLine("LISTENING..."); // sync workaround var syncManager = new SyncManager("sync-config.json"); syncManager.StartReplications(); Console.ReadKey(true); listener.Stop(); }
static void Main() { Manager manager = Manager.SharedInstance; var database = manager.GetDatabase("kis-database"); var cert = X509Manager.GetPersistentCertificate("127.0.0.1", "123abc", System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "unit_test.pfx")); Uri uri = new Uri(String.Format("http://localhost:{0}/{1}/", 3689, "database")); CouchbaseLiteTcpOptions options = new CouchbaseLiteTcpOptions(); CouchbaseLiteTcpListener listener = new CouchbaseLiteTcpListener(manager, 3689, CouchbaseLiteTcpOptions.UseTLS, cert); listener.SetPasswords(new Dictionary<string, string>() { { "user", "pass" } }); listener.Start(); Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new Form1()); }
public void TestSsl() { var cert = SSLGenerator.GetExistingCertificate("127.0.0.1", 59841); if (cert == null) { cert = SSLGenerator.GenerateCert("127.0.0.1", new RSACryptoServiceProvider(2048)); SSLGenerator.InstallCertificateForListener(cert, 59841); } var sslListener = new CouchbaseLiteTcpListener(manager, 59841, CouchbaseLiteTcpOptions.UseTLS); sslListener.Start(); ServicePointManager.ServerCertificateValidationCallback = (object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors) => { // If the certificate is a valid, signed certificate, return true. if (sslPolicyErrors == SslPolicyErrors.None) { return true; } // If there are errors in the certificate chain, look at each error to determine the cause. if ((sslPolicyErrors & SslPolicyErrors.RemoteCertificateChainErrors) != 0) { if (chain != null && chain.ChainStatus != null) { foreach (X509ChainStatus status in chain.ChainStatus) { if ((certificate.Subject == certificate.Issuer) && (status.Status == X509ChainStatusFlags.UntrustedRoot)) { // Self-signed certificates with an untrusted root are valid. continue; } else { if (status.Status != X509ChainStatusFlags.NoError) { // If there are any other errors in the certificate chain, the certificate is invalid, // so the method returns false. return false; } } } } // When processing reaches this line, the only errors in the certificate chain are // untrusted root errors for self-signed certificates. These certificates are valid // for default Exchange server installations, so return true. return true; } else { // In all other cases, return false. return false; } }; var request = (HttpWebRequest)WebRequest.Create("https://127.0.0.1:59841"); request.ClientCertificates.Add(SSLGenerator.GetOrCreateClientCert()); var response = (HttpWebResponse)request.GetResponse(); Assert.AreEqual(HttpStatusCode.OK, response.StatusCode); }
protected override void SetUp() { base.SetUp(); _listenerDB = EnsureEmptyDatabase(LISTENER_DB_NAME); _listener = new CouchbaseLiteTcpListener(manager, _port, CouchbaseLiteTcpOptions.Default); #if USE_AUTH _listener.SetPasswords(new Dictionary<string, string> { { "bob", "slack" } }); #endif _listenerDBUri = new Uri("http://localhost:" + _port + "/" + LISTENER_DB_NAME); _listener.Start(); }
public void TestReplicateWithListener() { var listener = new CouchbaseLiteTcpListener(manager, 59840); listener.Start(); var dbCopy = EnsureEmptyDatabase("replicate_end"); var push = database.CreatePushReplication(new Uri("http://localhost:59840/replicate_end")); CreateDocuments(database, 20); var attachDoc = CreateDocWithAttachment(database, "attachment.png", "image/png"); var attachDocId = attachDoc.Id; RunReplication(push); Assert.IsNull(push.LastError); Assert.AreEqual(21, dbCopy.DocumentCount); attachDoc = dbCopy.GetExistingDocument(attachDocId); Assert.IsNotNull(attachDoc, "Failed to store doc with attachment"); Assert.IsNotNull(attachDoc.CurrentRevision.Attachments, "Failed to store attachments on attachment doc"); var name = database.Name; database.Close(); database = EnsureEmptyDatabase(name); var pull = database.CreatePullReplication(new Uri("http://localhost:59840/replicate_end")); RunReplication(pull); Assert.IsNull(pull.LastError); Assert.AreEqual(21, database.DocumentCount); attachDoc = database.GetExistingDocument(attachDocId); Assert.IsNotNull(attachDoc, "Failed to retrieve doc with attachment"); Assert.IsNotNull(attachDoc.CurrentRevision.Attachments, "Failed to retrieve attachments on attachment doc"); // Now with auth // Digest listener.SetPasswords(new Dictionary<string, string> { { "jim", "borden" } }); dbCopy = EnsureEmptyDatabase("replicate_end"); push = database.CreatePushReplication(new Uri("http://localhost:59840/replicate_end")); push.Authenticator = new DigestAuthenticator("jim", "borden"); RunReplication(push); Assert.IsNull(push.LastError); Assert.AreEqual(21, dbCopy.DocumentCount); attachDoc = dbCopy.GetExistingDocument(attachDocId); Assert.IsNotNull(attachDoc, "Failed to store doc with attachment"); Assert.IsNotNull(attachDoc.CurrentRevision.Attachments, "Failed to store attachments on attachment doc"); name = database.Name; database.Close(); database = EnsureEmptyDatabase(name); pull = database.CreatePullReplication(new Uri("http://localhost:59840/replicate_end")); pull.Authenticator = push.Authenticator; RunReplication(pull); Assert.IsNull(pull.LastError); Assert.AreEqual(21, database.DocumentCount); attachDoc = database.GetExistingDocument(attachDocId); Assert.IsNotNull(attachDoc, "Failed to retrieve doc with attachment"); Assert.IsNotNull(attachDoc.CurrentRevision.Attachments, "Failed to retrieve attachments on attachment doc"); // and now Basic listener.Stop(); listener = new CouchbaseLiteTcpListener(manager, 59840, CouchbaseLiteTcpOptions.AllowBasicAuth); listener.SetPasswords(new Dictionary<string, string> { { "jim", "borden" } }); listener.Start(); dbCopy = EnsureEmptyDatabase("replicate_end"); push = database.CreatePushReplication(new Uri("http://localhost:59840/replicate_end")); push.Authenticator = new BasicAuthenticator("jim", "borden"); RunReplication(push); Assert.IsNull(push.LastError); Assert.AreEqual(21, dbCopy.DocumentCount); attachDoc = dbCopy.GetExistingDocument(attachDocId); Assert.IsNotNull(attachDoc, "Failed to store doc with attachment"); Assert.IsNotNull(attachDoc.CurrentRevision.Attachments, "Failed to store attachments on attachment doc"); name = database.Name; database.Close(); database = EnsureEmptyDatabase(name); pull = database.CreatePullReplication(new Uri("http://localhost:59840/replicate_end")); pull.Authenticator = push.Authenticator; RunReplication(pull); Assert.IsNull(pull.LastError); Assert.AreEqual(21, database.DocumentCount); attachDoc = database.GetExistingDocument(attachDocId); Assert.IsNotNull(attachDoc, "Failed to retrieve doc with attachment"); Assert.IsNotNull(attachDoc.CurrentRevision.Attachments, "Failed to retrieve attachments on attachment doc"); }
public void TestReplicateWithListener() { var listener = new CouchbaseLiteTcpListener(manager, 59840); listener.Start(); var dbCopy = EnsureEmptyDatabase("replicate_end"); var push = database.CreatePushReplication(new Uri("http://localhost:59840/replicate_end")); CreateDocuments(database, 20); var attachDoc = CreateDocWithAttachment(database, "attachment.png", "image/png"); var attachDocId = attachDoc.Id; RunReplication(push); Assert.IsNull(push.LastError); Assert.AreEqual(21, dbCopy.DocumentCount); attachDoc = dbCopy.GetExistingDocument(attachDocId); Assert.IsNotNull(attachDoc, "Failed to store doc with attachment"); Assert.IsNotNull(attachDoc.CurrentRevision.Attachments, "Failed to store attachments on attachment doc"); var name = database.Name; database.Close(); database = EnsureEmptyDatabase(name); var pull = database.CreatePullReplication(new Uri("http://localhost:59840/replicate_end")); RunReplication(pull); Assert.IsNull(pull.LastError); Assert.AreEqual(21, database.DocumentCount); attachDoc = database.GetExistingDocument(attachDocId); Assert.IsNotNull(attachDoc, "Failed to retrieve doc with attachment"); Assert.IsNotNull(attachDoc.CurrentRevision.Attachments, "Failed to retrieve attachments on attachment doc"); listener.Stop(); // TODO: Auth }
public static void Main(string[] args) { Couchbase.Lite.Util.Log.SetLogger(Logger); var alternateDir = default(string); var pullUrl = default(Uri); var pushUrl = default(Uri); var portToUse = DefaultPort; var readOnly = false; var requiresAuth = false; var createTarget = false; var continuous = false; var userName = default(string); var password = default(string); var useSSL = false; var sslCertPath = default(string); var sslCertPass = default(string); var storageType = "SQLite"; var passwordMap = new Dictionary<string, string>(); var showHelp = false; var revsLimit = 0; View.Compiler = new JSViewCompiler(); var options = new OptionSet { { "dir=", "Specifies an alternate directory to store databases in", v => alternateDir = v }, { "port=", "Specifies the port to listen on (default 59840)", v => portToUse = Int32.Parse(v) }, { "readonly", "Enables readonly mode", v => readOnly = v != null }, { "auth", "Set listener to require HTTP auth", v => requiresAuth = v != null }, { "pull=", "Specifies a remote database to pull from", v => pullUrl = new Uri(v) }, { "push=", "Specifies a remote database to push to", v => pushUrl = new Uri(v) }, { "create-target", "Creates the replication target database, if pull", v => createTarget = v != null }, { "continuous", "Specifies continuous replication", v => continuous = v != null }, { "user="******"Specifies a username for connecting to a remote database", v => userName = v }, { "password="******"Specifies a password for connection to a remote database", v => password = v }, { "revs_limit=", "Sets default max rev-tree depth for databases", v => revsLimit = Int32.Parse(v) }, { "ssl", "Serve over SSL", v => useSSL = v != null }, { "sslcert=", "Path to the SSL certificate to use", v => sslCertPath = v }, { "sslpass="******"Password for the SSL certificate", v => sslCertPass = v }, { "storage=", "Set default storage engine ('SQLite' (default) or 'ForestDB')", v => storageType = v }, { "dbpassword="******"Register password to open a database (name=password)", v => RegisterPassword(passwordMap, v) }, { "help|h|?", "Show this help message", v => showHelp = v != null } }; try { var remaining = options.Parse(args); foreach(var arg in remaining) { Logger.W("Listener", "Unrecognized argument {0}, ignoring...", arg); } } catch(Exception e) { Logger.E("Listener", "Error parsing arguments", e); ShowHelp(options); Exit(); return; } if (showHelp) { ShowHelp(options); Exit(); return; } Couchbase.Lite.Storage.ForestDB.Plugin.Register(); Couchbase.Lite.Storage.SQLCipher.Plugin.Register(); var manager = alternateDir != null ? new Manager(new DirectoryInfo(alternateDir), ManagerOptions.Default) : Manager.SharedInstance; manager.StorageType = storageType; if(revsLimit > 0) { // Note: Internal API (used for testing) manager.DefaultMaxRevTreeDepth = revsLimit; } if (passwordMap.Count > 0) { foreach (var entry in passwordMap) { #pragma warning disable 618 manager.RegisterEncryptionKey(entry.Key, new SymmetricKey(entry.Value)); #pragma warning restore 618 } } var tcpOptions = CouchbaseLiteTcpOptions.Default | CouchbaseLiteTcpOptions.AllowBasicAuth; var sslCert = default(X509Certificate2); if (useSSL) { tcpOptions |= CouchbaseLiteTcpOptions.UseTLS; if (sslCertPath != null) { if (!File.Exists(sslCertPath)) { Logger.E("Listener", "No file exists at given path for SSL cert ({0})", sslCertPath); Exit(); return; } try { sslCert = new X509Certificate2(sslCertPath, sslCertPass); } catch(Exception e) { Logger.E("Listener", "Error reading SSL cert ({0}), {1}", sslCertPath, e); Exit(); return; } } } var replicator = default(Replication); if (pushUrl != null || pullUrl != null) { replicator = SetupReplication(manager, continuous, createTarget, pushUrl ?? pullUrl, pullUrl != null, userName, password); if (replicator == null) { Exit(); return; } } CouchbaseLiteServiceListener listener = new CouchbaseLiteTcpListener(manager, (ushort)portToUse, tcpOptions, sslCert); listener.ReadOnly = readOnly; if (requiresAuth) { var random = new Random(); var generatedPassword = random.Next().ToString(); listener.SetPasswords(new Dictionary<string, string> { { "cbl", generatedPassword } }); Logger.I("Listener", "Auth required: user='******', password='******'", generatedPassword); } listener.Start(); Logger.I("Listener", "LISTENING..."); var wait = new ManualResetEventSlim(); Console.WriteLine("Press Ctrl+C to end the process"); Console.CancelKeyPress += (sender, e) => wait.Set(); wait.Wait(); Console.WriteLine("Shutting down now"); wait.Dispose(); foreach(var db in manager.AllOpenDatabases()) { db.Close(); } if (replicator != null) { replicator.Stop(); Thread.Sleep(5000); } }
public void TestSsl() { var cert = X509Manager.GetPersistentCertificate("127.0.0.1", "123abc", System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "unit_test.pfx")); var sslListener = new CouchbaseLiteTcpListener(manager, 59841, CouchbaseLiteTcpOptions.UseTLS, cert); sslListener.Start(); ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls; ServicePointManager.ServerCertificateValidationCallback = (object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors) => { // If the certificate is a valid, signed certificate, return true. if (sslPolicyErrors == SslPolicyErrors.None || sslPolicyErrors == SslPolicyErrors.RemoteCertificateNameMismatch) { return true; } // If there are errors in the certificate chain, look at each error to determine the cause. if ((sslPolicyErrors & SslPolicyErrors.RemoteCertificateChainErrors) != 0) { if (chain != null && chain.ChainStatus != null) { foreach (X509ChainStatus status in chain.ChainStatus) { if ((certificate.Subject == certificate.Issuer) && (status.Status == X509ChainStatusFlags.UntrustedRoot)) { // Self-signed certificates with an untrusted root are valid. continue; } else { if (status.Status != X509ChainStatusFlags.NoError) { // If there are any other errors in the certificate chain, the certificate is invalid, // so the method returns false. return false; } } } } // When processing reaches this line, the only errors in the certificate chain are // untrusted root errors for self-signed certificates. These certificates are valid // for default Exchange server installations, so return true. return true; } else { // In all other cases, return false. return false; } }; try { var request = (HttpWebRequest)WebRequest.Create("https://127.0.0.1:59841/"); var response = (HttpWebResponse)request.GetResponse(); Assert.AreEqual(HttpStatusCode.OK, response.StatusCode); request = (HttpWebRequest)WebRequest.Create("http://127.0.0.1:59841/"); Assert.Throws<WebException>(() => response = (HttpWebResponse)request.GetResponse()); } finally { sslListener.Stop(); } }