/// <summary>
/// Starts a replication for the session
/// </summary>
/// <param name="username">The username to use for the replication</param>
/// <param name="password">The password to use for replication auth (optional)</param>
public static void StartReplication(string username, string password = null)
{
var authenticator = default(IAuthenticator);
if (username != null && password != null)
{
authenticator = AuthenticatorFactory.CreateBasicAuthenticator(username, password);
}
var db = AppWideManager.GetDatabase(username);
var pusher = db.CreatePushReplication(SyncGatewayUrl);
pusher.Continuous = true;
pusher.Authenticator = authenticator;
pusher.Changed += HandleReplicationChanged;
var puller = db.CreatePullReplication(SyncGatewayUrl);
puller.Continuous = true;
puller.Authenticator = authenticator;
puller.Changed += HandleReplicationChanged;
pusher.Start();
puller.Start();
_pusher = pusher;
_puller = puller;
}
public void TestGetAuthenticationHeaderValue()
{
var username1 = "username1";
var password1 = "password1";
var credParam1 = Convert.ToBase64String(
Encoding.UTF8.GetBytes(string.Format("{0}:{1}", username1, password1)));
var auth = AuthenticatorFactory.CreateBasicAuthenticator(username1, password1) as BasicAuthenticator;
var authHeader = auth.AuthorizationHeaderValue;
Assert.IsNotNull(authHeader);
Assert.AreEqual(credParam1, authHeader.Split(' ')[1]);
var username2 = "username2";
var password2 = "password2";
var credParam2 = Convert.ToBase64String(
Encoding.UTF8.GetBytes(string.Format("{0}:{1}", username2, password2)));
var userinfo = username2 + ":" + password2;
var uri = new Uri("http://" + userinfo + "@couchbase.com");
auth = (BasicAuthenticator)AuthenticatorFactory.CreateFromUri(uri);
authHeader = auth.AuthorizationHeaderValue;
Assert.IsNotNull(authHeader);
Assert.AreEqual(credParam2, authHeader.Split(' ')[1]);
uri = new Uri("http://www.couchbase.com");
auth = (BasicAuthenticator)AuthenticatorFactory.CreateFromUri(uri);
Assert.IsNull(auth);
var auth2 = AuthenticatorFactory.CreateFacebookAuthenticator("1234") as ICustomHeadersAuthorizer;
Assert.IsNull(auth2);
}
public void TestGetAuthenticationHeaderValue()
{
var username1 = "username1";
var password1 = "password1";
var credParam1 = Convert.ToBase64String(
Encoding.UTF8.GetBytes(string.Format("{0}:{1}", username1, password1)));
var auth = AuthenticatorFactory.CreateBasicAuthenticator(username1, password1);
var authHeader = AuthUtils.GetAuthenticationHeaderValue(auth, null);
Assert.IsNotNull(authHeader);
Assert.AreEqual(credParam1, authHeader.Parameter);
var username2 = "username2";
var password2 = "password2";
var credParam2 = Convert.ToBase64String(
Encoding.UTF8.GetBytes(string.Format("{0}:{1}", username2, password2)));
var userinfo = username2 + ":" + password2;
var uri = new Uri("http://" + userinfo + "@couchbase.com");
var request = new HttpRequestMessage(HttpMethod.Get, uri);
authHeader = AuthUtils.GetAuthenticationHeaderValue(auth, request.RequestUri);
Assert.IsNotNull(authHeader);
Assert.AreEqual(credParam2, authHeader.Parameter);
uri = new Uri("http://www.couchbase.com");
request = new HttpRequestMessage(HttpMethod.Get, uri);
authHeader = AuthUtils.GetAuthenticationHeaderValue(null, request.RequestUri);
Assert.IsNull(authHeader);
auth = AuthenticatorFactory.CreateFacebookAuthenticator("1234");
authHeader = AuthUtils.GetAuthenticationHeaderValue(auth, null);
Assert.IsNull(authHeader);
}
public void TestBasicAuthenticationSuccess()
{
if (!Boolean.Parse((string)GetProperty("replicationTestsEnabled")))
{
Assert.Inconclusive("Server tests disabled.");
return;
}
var username = "******";
var password = "******";
AddUser(username, password);
var url = GetReplicationURLWithoutCredentials();
var replicator = database.CreatePushReplication(url);
replicator.Authenticator = AuthenticatorFactory.CreateBasicAuthenticator(username, password);
Assert.IsNotNull(replicator);
Assert.IsNotNull(replicator.Authenticator);
Assert.IsTrue(replicator.Authenticator is BasicAuthenticator);
RunReplication(replicator);
var lastError = replicator.LastError;
Assert.IsNull(lastError);
Thread.Sleep(200);
}
private static Replication SetupReplication(Manager manager, bool continuous, bool createTarget, Uri remoteUri, bool isPull, string user, string password)
{
if (remoteUri == null)
{
return(null);
}
var databaseName = remoteUri.Segments.Last();
var authenticator = default(IAuthenticator);
if (user != null && password != null)
{
Console.WriteLine("Setting session credentials for user '{0}'", user);
authenticator = AuthenticatorFactory.CreateBasicAuthenticator(user, password);
}
if (isPull)
{
Console.WriteLine("Pulling from <{0}> --> {1}", remoteUri, databaseName);
}
else
{
Console.WriteLine("Pushing {0} --> <{1}>", databaseName, remoteUri);
}
var db = manager.GetExistingDatabase(databaseName);
if (isPull && db == null)
{
db = manager.GetDatabase(databaseName);
}
if (db == null)
{
Console.Error.WriteLine("Couldn't open database {0}", databaseName);
return(null);
}
var repl = isPull ? db.CreatePullReplication(remoteUri) : db.CreatePushReplication(remoteUri);
repl.Continuous = continuous;
repl.CreateTarget = createTarget;
repl.Authenticator = authenticator;
repl.Changed += (sender, e) =>
{
Console.WriteLine("*** Replicator status changed ({0} {1}/{2}) ***", e.Status, e.CompletedChangesCount, e.ChangesCount);
if (e.LastError != null)
{
Console.Error.WriteLine("*** Replicator reported error ***", e);
}
else if (e.Status == ReplicationStatus.Stopped)
{
Console.WriteLine("*** Replicator finished ***");
}
};
repl.Start();
return(repl);
}
public static void Main(string[] args)
{
var syncGatewayUrl = new Uri("http://localhost:4984/db/");
Manager manager = Manager.SharedInstance;
Database airlineDb = manager.GetDatabase("airline");
Database routeDb = manager.GetDatabase("route");
Database airportDb = manager.GetDatabase("airport");
Database landmarkDb = manager.GetDatabase("landmark");
Database hotelDb = manager.GetDatabase("hotel");
// Total docs: 31591
var testDbs = new TestDatabase[] {
new TestDatabase(airlineDb, "airline", "pass", 187),
new TestDatabase(routeDb, "route", "pass", 24024),
new TestDatabase(airportDb, "airport", "pass", 1968),
new TestDatabase(landmarkDb, "landmark", "pass", 4495),
new TestDatabase(hotelDb, "hotel", "pass", 917),
};
// Start continuous push / pull replications for each database
foreach (var testDb in testDbs)
{
IAuthenticator replicationAuth = AuthenticatorFactory.CreateBasicAuthenticator(testDb.UserName, testDb.Password);
Replication pullReplication = testDb.Database.CreatePullReplication(syncGatewayUrl);
pullReplication.Authenticator = replicationAuth;
pullReplication.Continuous = true;
pullReplication.Start();
Replication pushReplication = testDb.Database.CreatePushReplication(syncGatewayUrl);
pushReplication.Authenticator = replicationAuth;
pushReplication.Continuous = true;
pushReplication.Start();
}
// Wait for replication to stop
var timeout = TimeSpan.FromMinutes(20);
// Poll until all dbs have the expected number of docs
WaitForImport(testDbs, timeout);
// Update each doc via Lite
TouchAllDocs(testDbs);
// Run python script to update all the docs via the SDK
Console.WriteLine("\nWaiting for SDK to perform updates ...");
var line = Console.ReadLine();
// Wait for replication to stop
WaitForSDKUpdates(testDbs, timeout);
}
private void StartReplications()
{
_pull = _db.CreatePullReplication(CreateSyncUri());
_push = _db.CreatePushReplication(CreateSyncUri());
var authenticator = AuthenticatorFactory.CreateBasicAuthenticator(User, Password);
_pull.Authenticator = authenticator;
_push.Authenticator = authenticator;
_pull.Continuous = true;
_push.Continuous = true;
// _pull.Start();
// _push.Start();
_push.Changed += OnPushChanged;
}
public void TestBasicAuthenticationWrongPassword()
{
if (!Boolean.Parse((string)Runtime.Properties["replicationTestsEnabled"]))
{
Assert.Inconclusive("Server tests disabled.");
return;
}
var username = "******";
var password = "******";
var wrongPassword = "******";
AddUser(username, password);
var url = GetReplicationURLWithoutCredentials();
var httpClientFactory = new CouchbaseLiteHttpClientFactory(new CookieStore());
manager.DefaultHttpClientFactory = httpClientFactory;
var replicator = database.CreatePushReplication(url);
replicator.Authenticator = AuthenticatorFactory.CreateBasicAuthenticator(username, wrongPassword);
Assert.IsNotNull(replicator);
Assert.IsNotNull(replicator.Authenticator);
Assert.IsTrue(replicator.Authenticator is BasicAuthenticator);
replicator.Start();
var doneEvent = new ManualResetEvent(false);
Task.Factory.StartNew(() =>
{
var timeout = DateTime.UtcNow + TimeSpan.FromSeconds(30);
var stop = false;
while (DateTime.UtcNow < timeout && !stop)
{
stop |= replicator.Status != ReplicationStatus.Active;
Sleep(TimeSpan.FromMilliseconds(10));
}
doneEvent.Set();
});
doneEvent.WaitOne(TimeSpan.FromSeconds(10));
Sleep(1000);
var lastError = replicator.LastError;
Assert.IsNotNull(lastError);
}
public void TestAuthenticationFactory()
{
var basicAuth = AuthenticatorFactory.CreateBasicAuthenticator("username", "password");
Assert.IsNotNull(basicAuth);
Assert.IsTrue(basicAuth is BasicAuthenticator);
var facebookAuth = AuthenticatorFactory.CreateFacebookAuthenticator("DUMMY_TOKEN");
Assert.IsNotNull(facebookAuth);
Assert.IsTrue(facebookAuth is TokenAuthenticator);
var personalAuth = AuthenticatorFactory.CreatePersonaAuthenticator("DUMMY_ASSERTION", null);
Assert.IsNotNull(personalAuth);
Assert.IsTrue(personalAuth is TokenAuthenticator);
}
public virtual void TestAuthenticatorFactory()
{
Authenticator basicAuth = AuthenticatorFactory.CreateBasicAuthenticator("username"
, "password");
NUnit.Framework.Assert.IsNotNull(basicAuth);
NUnit.Framework.Assert.IsTrue(basicAuth is BasicAuthenticator);
Authenticator facebookAuth = AuthenticatorFactory.CreateFacebookAuthenticator("DUMMY_TOKEN"
);
NUnit.Framework.Assert.IsNotNull(facebookAuth);
NUnit.Framework.Assert.IsTrue(facebookAuth is TokenAuthenticator);
Authenticator personalAuth = AuthenticatorFactory.CreatePersonaAuthenticator("DUMMY_ASSERTION"
, null);
NUnit.Framework.Assert.IsNotNull(personalAuth);
NUnit.Framework.Assert.IsTrue(personalAuth is TokenAuthenticator);
}
public void StartSyncGateway(string url = "")
{
pull = _database.CreatePullReplication(CreateSyncUri());
push = _database.CreatePushReplication(CreateSyncUri());
var authenticator = AuthenticatorFactory.CreateBasicAuthenticator("david", "12345");
pull.Authenticator = authenticator;
push.Authenticator = authenticator;
pull.Continuous = true;
push.Continuous = true;
pull.Changed += Pull_Changed;
push.Changed += Push_Changed;
pull.Start();
push.Start();
}
public MainPage()
{
InitializeComponent();
Title = "Run Lover";
mHistory = new List <RunData>();
listHistory.ItemsSource = mHistory;
ReadHistoryData();
Database database = Couchbase.Lite.Manager.SharedInstance.GetDatabase(RunData.LOCAL_DB_NAME);
Replication downloader = database.CreatePullReplication(new Uri(DATABASE_URL + "/" + DATABASE_NAME));
downloader.Authenticator = AuthenticatorFactory.CreateBasicAuthenticator(USERNAME, PASSWORD);
downloader.Changed += OnReplicationChange;
downloader.Start();
}
public void TestBasicAuthenticationWrongPassword()
{
var username = "******";
var password = "******";
var wrongPassword = "******";
AddUser(username, password);
var url = GetReplicationURLWithoutCredentials();
var httpClientFactory = new CouchbaseLiteHttpClientFactory(new CookieStore());
manager.DefaultHttpClientFactory = httpClientFactory;
var replicator = database.CreatePushReplication(url);
replicator.Authenticator = AuthenticatorFactory.CreateBasicAuthenticator(username, wrongPassword);
Assert.IsNotNull(replicator);
Assert.IsNotNull(replicator.Authenticator);
Assert.IsTrue(replicator.Authenticator is BasicAuthenticator);
replicator.Start();
var doneEvent = new ManualResetEvent(false);
Task.Factory.StartNew(() =>
{
var timeout = DateTime.UtcNow + TimeSpan.FromSeconds(30);
var stop = false;
while (DateTime.UtcNow < timeout && !stop)
{
stop |= !replicator.active;
Thread.Sleep(TimeSpan.FromMilliseconds(10));
}
doneEvent.Set();
});
doneEvent.WaitOne(TimeSpan.FromSeconds(35));
Thread.Sleep(1000);
var lastError = replicator.LastError;
Assert.IsNotNull(lastError);
}
/// <summary>
/// Replicates all pending documents for a given replication and then returns.
/// </summary>
/// <param name="replication">The replication.</param>
/// <returns>The number of replicated documents.</returns>
private int ReplicatePending(Replication replication)
{
var isFinished = false;
replication.Authenticator = AuthenticatorFactory.CreateBasicAuthenticator(UserId, Password);
replication.Changed +=
(s, a) =>
{
if (a.Status == ReplicationStatus.Stopped)
{
isFinished = true;
}
};
replication.Start();
NeonHelper.WaitFor(() => isFinished, TimeSpan.FromSeconds(10));
return(replication.CompletedChangesCount);
}
public void StartSyncGateway(string scheme = "https", string hostname = "localhost", int port = 4984, string dbname = "beer", string username = "******", string password = "******")
{
Uri uri = CreateSyncUri(scheme, hostname, port, dbname);
pull = _database.CreatePullReplication(uri);
push = _database.CreatePushReplication(uri);
var authenticator = AuthenticatorFactory.CreateBasicAuthenticator(username, password);
pull.Authenticator = authenticator;
push.Authenticator = authenticator;
pull.Continuous = true;
push.Continuous = true;
pull.Changed += Pull_Changed;
push.Changed += Push_Changed;
pull.Start();
push.Start();
}
private async void OnSaveClick()
{
Dictionary <string, object> data = RunData.CreateDictionary(
new DateTimeOffset(mStartTime).ToUnixTimeMilliseconds(), (long)mDuration.TotalMilliseconds,
mDistance, mStartCoordinate, mFinishCoordinate);
Database database = Couchbase.Lite.Manager.SharedInstance.GetDatabase(RunData.LOCAL_DB_NAME);
Document document = database.CreateDocument();
document.PutProperties(data);
Replication uploader = database.CreatePushReplication(new Uri(DATABASE_URL + "/" + DATABASE_NAME));
uploader.Authenticator = AuthenticatorFactory.CreateBasicAuthenticator(USERNAME, PASSWORD);
uploader.Start();
await Navigation.PushAsync(new DetailPage(new RunData(data)));
//Navigation.RemovePage(this);
}
public void TestBasicAuthenticationWrongPassword()
{
if (!Boolean.Parse((string)GetProperty("replicationTestsEnabled")))
{
Assert.Inconclusive("Server tests disabled.");
return;
}
var username = "******";
var password = "******";
var wrongPassword = "******";
AddUser(username, password);
CreateDocuments(database, 10);
var url = GetReplicationURLWithoutCredentials();
var replicator = database.CreatePushReplication(url);
replicator.Authenticator = AuthenticatorFactory.CreateBasicAuthenticator(username, wrongPassword);
Assert.IsNotNull(replicator);
Assert.IsNotNull(replicator.Authenticator);
Assert.IsTrue(replicator.Authenticator is BasicAuthenticator);
RunReplication(replicator);
var lastError = replicator.LastError as HttpResponseException;
Assert.IsNotNull(lastError);
Assert.AreEqual(HttpStatusCode.Unauthorized, lastError.StatusCode);
Assert.IsTrue(lastError.Data.Contains("AuthChallenge"));
var errorData = lastError.Data["AuthChallenge"].AsDictionary <string, string>();
Assert.IsNotNull(errorData);
Assert.AreEqual("Basic", errorData["Scheme"]);
Assert.AreEqual("Couchbase Sync Gateway", errorData["realm"]);
}
protected void Replicate(string localDbName, string remoteDbName, List <string> channels)
{
var url = new Uri(syncGateway + "/" + remoteDbName + "/");
database = Manager.SharedInstance.GetDatabase(localDbName);
pull = database.CreatePullReplication(url);
push = database.CreatePushReplication(url);
var auth = AuthenticatorFactory.CreateBasicAuthenticator(this.username, this.password);
//Pull process
pull.Channels = channels;
pull.Authenticator = auth;
pull.Continuous = true;
pull.Changed += PullChanged;
pull.Start();
//Push process
push.Authenticator = auth;
push.Continuous = true;
push.Start();
}
public CouchDbGeoObjectsService()
{
var url = new Uri("http://104.236.29.68:4985/sync_gateway/");
var auth = AuthenticatorFactory.CreateBasicAuthenticator("mobile", "123123");
var pull = _db.CreatePullReplication(url);
pull.Continuous = true;
pull.Channels = new[] { "geo" };
pull.Authenticator = auth;
pull.Start();
var view = _db.GetView("geo");
view.SetMap((document, emit) =>
{
if (document.ContainsKey("geometry") && document.ContainsKey("name"))
{
emit(new[] { document["geometry"] }, document);
}
}, "1");
_docs = view.CreateQuery().Run();
}
private void SetupReplication(Uri server)
{
#if (!CB_SYNC_ENABLED)
Console.WriteLine("Sync is DISABLED");
return;
#endif
Console.WriteLine("Setting up replication");
var pull = _db.CreatePullReplication(server);
var push = _db.CreatePushReplication(server);
pull.Continuous = true;
push.Continuous = true;
#if (CB_USER_AUTH_ENABLED)
var userId = GetUserId();
pull.Authenticator = AuthenticatorFactory.CreateBasicAuthenticator(userId, userId);
push.Authenticator = AuthenticatorFactory.CreateBasicAuthenticator(userId, userId);
#endif
pull.Start();
push.Start();
}
public async Task SingleUser()
{
// Perform an end-to-end integration test where we provision
// the Sync Gateway with a user and verify that document R/W
// and replication works.
string tempFolder = null;
Database db0 = null;
Database db1 = null;
Manager manager = null;
try
{
tempFolder = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
Directory.CreateDirectory(tempFolder);
await TestCluster.ClearAsync();
using (var gateway = TestCluster.CreateGateway())
{
var gatewayManager = gateway.CreateManager();
await TestCluster.CreateDatabaseAsync("db");
await gatewayManager.RoleCreateAsync("db",
new RoleProperties()
{
Name = "role0",
AdminChannels = new List <string>()
{
$"role-channel"
}
});
await gatewayManager.UserCreateAsync("db",
new UserProperties()
{
Name = "user0",
Password = "******",
Email = "*****@*****.**",
IsDisabled = false,
AdminChannels = new List <string>()
{
"user-channel"
},
Roles = new List <string>()
{
"role0"
}
});
// Create two local databases for the same user.
manager = new Manager(new DirectoryInfo(tempFolder), new ManagerOptions());
var auth = AuthenticatorFactory.CreateBasicAuthenticator("user0", "password0");
db0 = manager.GetDatabase("db0");
db1 = manager.GetDatabase("db1");
var db0ExternalChange = false;
var db1ExternalChange = false;
db0.Changed +=
(s, a) =>
{
Debug.Write($"*** db0: Count={a.Changes.Count()} External={a.IsExternal}");
if (a.Changes.Count() > 0 && a.IsExternal)
{
db0ExternalChange = true;
}
};
db1.Changed +=
(s, a) =>
{
Debug.Write($"*** db1: Count={a.Changes.Count()} External={a.IsExternal}");
if (a.Changes.Count() > 0 && a.IsExternal)
{
db1ExternalChange = true;
}
};
// Here's the meat of the test:
//
// 1. Create push and pull replicators for each database.
// 2. Write a document to one database
// 3. Verify that the source database's push replicator pushed the document
// 4. ...and the target database's pull replicator pulled the document
var db0Pull = db0.CreatePullReplication(new Uri(gateway.GetDatabaseUri("db")));
db0Pull.Authenticator = auth;
db0Pull.Continuous = true;
db0Pull.Start();
var db0Push = db0.CreatePushReplication(new Uri(gateway.GetDatabaseUri("db")));
db0Push.Authenticator = auth;
db0Push.Continuous = true;
db0Push.Start();
var db1Pull = db1.CreatePullReplication(new Uri(gateway.GetDatabaseUri("db")));
db1Pull.Authenticator = auth;
db1Pull.Continuous = true;
db1Pull.Start();
var db1Push = db1.CreatePushReplication(new Uri(gateway.GetDatabaseUri("db")));
db1Push.Authenticator = auth;
db1Push.Continuous = true;
db1Push.Start();
// Write a document to db0 and wait for the replication to db1.
var source = db0.GetDocument("doc-0");
var properties = new Dictionary <string, object>()
{
{ "+c", "doc0" },
{ "+ch", new string[] { "user-channel" } }
};
source.PutProperties(properties);
var target = db0.GetDocument("doc-0");
Assert.Equal("doc0", target.Properties["+c"]);
NeonHelper.WaitFor(() => !db0Push.IsDocumentPending(target), MaxWait);
NeonHelper.WaitFor(() => db1ExternalChange, MaxWait);
target = db1.GetDocument("doc-0");
Assert.Equal("doc0", target.Properties["+c"]);
// Write a document to db1 and wait for the replication to db0.
db0ExternalChange = db1ExternalChange = false;
source = db1.GetDocument("doc-1");
properties = new Dictionary <string, object>()
{
{ "+c", "doc1" },
{ "+ch", new string[] { "user-channel" } }
};
source.PutProperties(properties);
target = db1.GetDocument("doc-1");
Assert.Equal("doc1", target.Properties["+c"]);
NeonHelper.WaitFor(() => !db1Push.IsDocumentPending(target), MaxWait);
NeonHelper.WaitFor(() => db0ExternalChange, MaxWait);
target = db1.GetDocument("doc-1");
Assert.Equal("doc1", target.Properties["+c"]);
}
}
finally
{
if (db0 != null)
{
db0.Dispose();
}
if (db1 != null)
{
db1.Dispose();
}
if (manager != null)
{
manager.Close();
}
await TestCluster.ClearAsync();
Directory.Delete(tempFolder, recursive: true);
}
}
public IAuthenticator CreateAuthenticator(ReplicationDriverContext context)
{
return(AuthenticatorFactory.CreateBasicAuthenticator(this._username, this._password));
}