/*
* Syncany, www.syncany.org
* Copyright (C) 2011-2014 Philipp C. Heckel <philipp.heckel@gmail.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.syncany.tests.daemon;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import java.util.HashMap;
import java.util.Map;
import org.junit.Test;
import org.syncany.config.LocalEventBus;
import org.syncany.config.to.DaemonConfigTO;
import org.syncany.database.FileVersion;
import org.syncany.operations.daemon.WatchServer;
import org.syncany.operations.daemon.messages.AlreadySyncingResponse;
import org.syncany.operations.daemon.messages.GetFileFolderRequest;
import org.syncany.operations.daemon.messages.GetFileFolderResponseInternal;
import org.syncany.operations.daemon.messages.GetFileHistoryFolderRequest;
import org.syncany.operations.daemon.messages.GetFileHistoryFolderResponse;
import org.syncany.operations.daemon.messages.LsFolderRequest;
import org.syncany.operations.daemon.messages.LsFolderResponse;
import org.syncany.operations.daemon.messages.RestoreFolderRequest;
import org.syncany.operations.daemon.messages.RestoreFolderResponse;
import org.syncany.operations.daemon.messages.StatusFolderRequest;
import org.syncany.operations.daemon.messages.StatusFolderResponse;
import org.syncany.operations.daemon.messages.api.Response;
import org.syncany.operations.ls.LsOperationOptions;
import org.syncany.operations.restore.RestoreOperationOptions;
import org.syncany.operations.status.StatusOperationOptions;
import org.syncany.plugins.transfer.TransferSettings;
import org.syncany.tests.util.TestClient;
import org.syncany.tests.util.TestConfigUtil;
import org.syncany.tests.util.TestDaemonUtil;
import org.syncany.util.FileUtil;
import com.google.common.eventbus.Subscribe;
/**
* The BasicWatchServerTest tests the WatchServer as a seperate entity. It
* should test if all basic functionality works as expected.
*
* @author Pim Otte
*/
public class BasicWatchServerTest {
private Map<Integer, Response> responses = new HashMap<Integer, Response>();
private GetFileFolderResponseInternal internalResponse;
private LocalEventBus eventBus;
/**
* The WatchServerTest tests all things WatchServer.
* This is one single test to prevent issues with parallelism. (Occupied ports, EventBus mixups etc.)
*/
@Test
public void testWatchServer() throws Exception {
final TransferSettings testConnection = TestConfigUtil.createTestLocalConnection();
final TestClient clientA = new TestClient("ClientA", testConnection);
final TestClient clientB = new TestClient("ClientB", testConnection);
int port = 58443;
// Load config template
DaemonConfigTO daemonConfig = TestDaemonUtil.loadDaemonConfig("daemonTwoFoldersNoWebServer.xml");
// Set port to prevent conflicts with default daemons
daemonConfig.getWebServer().setBindPort(port);
// Dynamically insert paths
daemonConfig.getFolders().get(0).setPath(clientA.getConfig().getLocalDir().getAbsolutePath());
daemonConfig.getFolders().get(1).setPath(clientB.getConfig().getLocalDir().getAbsolutePath());
// Create access token (not needed in this test, but prevents errors in daemon)
daemonConfig.setPortTO(TestDaemonUtil.createPortTO(port));
// Create watchServer
WatchServer watchServer = new WatchServer();
clientA.createNewFile("file-1");
watchServer.start(daemonConfig);
for (int i = 0; i < 20; i++) {
if (clientB.getLocalFile("file-1").exists()) {
break;
}
Thread.sleep(1000);
}
assertTrue("File has not synced to clientB", clientB.getLocalFile("file-1").exists());
assertEquals(clientA.getLocalFile("file-1").length(), clientB.getLocalFile("file-1").length());
registerWithBus();
// Create watchServer
clientA.createNewFolder("folder");
clientA.createNewFile("folder/file-2");
// Allow server to settle
Thread.sleep(100);
// Repeat request until 3 files are found.
FileVersion[] files = null;
for (int i = 0; i < 20; i++) {
LsFolderRequest request = new LsFolderRequest();
LsOperationOptions lsOperationOption = new LsOperationOptions();
request.setId(i);
request.setRoot(clientA.getConfig().getLocalDir().getAbsolutePath());
request.setOptions(lsOperationOption);
eventBus.post(request);
Response response = waitForResponse(i);
assertTrue(response instanceof LsFolderResponse);
LsFolderResponse treeResponse = (LsFolderResponse) response;
files = treeResponse.getResult().getFileTree().values().toArray(new FileVersion[]{});
if (files.length == 2) {
break;
}
if (i == 19) {
assertEquals(2, files.length);
}
else {
Thread.sleep(1000);
}
}
if (files[0].getName().equals("folder")) {
files = new FileVersion[]{files[1], files[0]};
}
assertEquals(clientA.getLocalFile("file-1").getName(), files[0].getName());
assertEquals(clientA.getLocalFile("file-1").length(), (long) files[0].getSize());
assertEquals(clientA.getLocalFile("folder").getName(), files[1].getName());
assertTrue(clientA.getLocalFile("folder").isDirectory());
assertEquals(files[1].getType(), FileVersion.FileType.FOLDER);
// Create GetFileHistoryRequest for the first returned file
GetFileHistoryFolderRequest request = new GetFileHistoryFolderRequest();
request.setId(21);
request.setRoot(clientA.getConfig().getLocalDir().getAbsolutePath());
request.setFileHistoryId(files[0].getFileHistoryId().toString());
eventBus.post(request);
Response response = waitForResponse(21);
assertTrue(response instanceof GetFileHistoryFolderResponse);
GetFileHistoryFolderResponse fileHistoryResponse = (GetFileHistoryFolderResponse) response;
assertEquals(1, fileHistoryResponse.getFiles().size());
assertEquals(files[0], fileHistoryResponse.getFiles().get(0));
// Create GetFileRequest for the first returned file
GetFileFolderRequest getFileRequest = new GetFileFolderRequest();
getFileRequest.setId(22);
getFileRequest.setRoot(clientA.getConfig().getLocalDir().getAbsolutePath());
getFileRequest.setFileHistoryId(files[0].getFileHistoryId().toString());
getFileRequest.setVersion(1);
eventBus.post(getFileRequest);
int i = 0;
while (internalResponse == null && i < 40) {
Thread.sleep(100);
i++;
}
assertEquals((long)files[0].getSize(), internalResponse.getTempFile().length());
// Cli Requests
clientA.copyFile("file-1", "file-1.bak");
// CLI request while running.
StatusFolderRequest statusRequest = new StatusFolderRequest();
StatusOperationOptions statusOperationOption = new StatusOperationOptions();
statusOperationOption.setForceChecksum(true);
statusRequest.setId(30);
statusRequest.setRoot(clientA.getConfig().getLocalDir().getAbsolutePath());
statusRequest.setOptions(statusOperationOption);
// Create big file to trigger sync
clientA.createNewFile("bigfileforlongsync", 5000);
// ^^ Now sync should start and we send 'status' requests
boolean syncRunningMessageReceived = false;
for (i = 30; i < 50; i++) {
statusRequest.setId(i);
eventBus.post(statusRequest);
response = waitForResponse(i);
if (response instanceof AlreadySyncingResponse) {
syncRunningMessageReceived = true;
break;
}
Thread.sleep(200);
}
assertTrue(syncRunningMessageReceived);
// Allow daemon to sync
Thread.sleep(10000);
for (i = 50; i < 60; i++) {
statusRequest.setId(i);
eventBus.post(statusRequest);
response = waitForResponse(i);
if (response instanceof StatusFolderResponse) {
break;
}
Thread.sleep(1000);
}
assertNotNull(response);
//assertEquals("No local changes.\n", cliResponse.getOutput());
// Restore file test
RestoreFolderRequest restoreRequest = new RestoreFolderRequest();
RestoreOperationOptions restoreOperationOption = new RestoreOperationOptions();
restoreOperationOption.setFileHistoryId(files[0].getFileHistoryId());
restoreOperationOption.setFileVersion(1);
restoreRequest.setId(70);
restoreRequest.setRoot(clientA.getConfig().getLocalDir().getAbsolutePath());
restoreRequest.setOptions(restoreOperationOption);
eventBus.post(restoreRequest);
response = waitForResponse(70);
assertTrue(response instanceof RestoreFolderResponse);
RestoreFolderResponse restoreResponse = (RestoreFolderResponse) response;
byte[] copyChecksum = FileUtil.createChecksum(clientA.getLocalFile("file-1.bak"), "SHA1");
byte[] restoreChecksum = FileUtil.createChecksum(restoreResponse.getResult().getTargetFile(), "SHA1");
assertArrayEquals(copyChecksum, restoreChecksum);
watchServer.stop();
clientA.deleteTestData();
clientB.deleteTestData();
}
private void registerWithBus() {
if (eventBus == null) {
eventBus = LocalEventBus.getInstance();
eventBus.register(this);
}
}
@Subscribe
public void onResponseReceived(Response response) {
responses.put(response.getRequestId(), response);
}
@Subscribe
public void onGetFileResponseInternal(GetFileFolderResponseInternal internalResponse) {
this.internalResponse = internalResponse;
}
private Response waitForResponse(int id) throws Exception {
int i = 0;
while (responses.containsKey(id) == false && i < 1000) {
Thread.sleep(100);
i++;
}
return responses.get(id);
}
}