478 lines
17 KiB
Java
478 lines
17 KiB
Java
package me.mrletsplay.shareclient;
|
|
|
|
import java.io.IOException;
|
|
import java.net.URI;
|
|
import java.nio.file.Files;
|
|
import java.nio.file.Path;
|
|
import java.util.Arrays;
|
|
import java.util.HashMap;
|
|
import java.util.Map;
|
|
import java.util.Random;
|
|
import java.util.UUID;
|
|
import java.util.function.Function;
|
|
import java.util.stream.Collectors;
|
|
|
|
import org.eclipse.core.resources.IFile;
|
|
import org.eclipse.core.resources.IProject;
|
|
import org.eclipse.core.resources.IProjectDescription;
|
|
import org.eclipse.core.resources.IResource;
|
|
import org.eclipse.core.resources.IResourceChangeEvent;
|
|
import org.eclipse.core.resources.IResourceDelta;
|
|
import org.eclipse.core.resources.IWorkspace;
|
|
import org.eclipse.core.resources.IWorkspaceRoot;
|
|
import org.eclipse.core.resources.ResourcesPlugin;
|
|
import org.eclipse.core.runtime.CoreException;
|
|
import org.eclipse.jface.dialogs.MessageDialog;
|
|
import org.eclipse.swt.widgets.Display;
|
|
import org.eclipse.ui.IStartup;
|
|
import org.eclipse.ui.PlatformUI;
|
|
import org.eclipse.ui.plugin.AbstractUIPlugin;
|
|
import org.osgi.framework.BundleContext;
|
|
|
|
import me.mrletsplay.shareclient.util.ChecksumUtil;
|
|
import me.mrletsplay.shareclient.util.Peer;
|
|
import me.mrletsplay.shareclient.util.ProjectAndPath;
|
|
import me.mrletsplay.shareclient.util.ProjectRelativePath;
|
|
import me.mrletsplay.shareclient.util.ShareSession;
|
|
import me.mrletsplay.shareclient.util.SharedProject;
|
|
import me.mrletsplay.shareclient.util.SyncState;
|
|
import me.mrletsplay.shareclient.util.listeners.ShareClientDocumentListener;
|
|
import me.mrletsplay.shareclient.util.listeners.ShareClientPageListener;
|
|
import me.mrletsplay.shareclient.util.listeners.ShareClientPartListener;
|
|
import me.mrletsplay.shareclient.util.listeners.ShareClientWindowListener;
|
|
import me.mrletsplay.shareclient.views.ShareView;
|
|
import me.mrletsplay.shareclientcore.connection.ConnectionException;
|
|
import me.mrletsplay.shareclientcore.connection.DisconnectListener;
|
|
import me.mrletsplay.shareclientcore.connection.MessageListener;
|
|
import me.mrletsplay.shareclientcore.connection.RemoteConnection;
|
|
import me.mrletsplay.shareclientcore.connection.WebSocketConnection;
|
|
import me.mrletsplay.shareclientcore.connection.message.AddressableMessage;
|
|
import me.mrletsplay.shareclientcore.connection.message.ChangeMessage;
|
|
import me.mrletsplay.shareclientcore.connection.message.ChecksumMessage;
|
|
import me.mrletsplay.shareclientcore.connection.message.FullSyncMessage;
|
|
import me.mrletsplay.shareclientcore.connection.message.Message;
|
|
import me.mrletsplay.shareclientcore.connection.message.PeerJoinMessage;
|
|
import me.mrletsplay.shareclientcore.connection.message.PeerLeaveMessage;
|
|
import me.mrletsplay.shareclientcore.connection.message.RequestFullSyncMessage;
|
|
import me.mrletsplay.shareclientcore.document.Char;
|
|
import me.mrletsplay.shareclientcore.document.SharedDocument;
|
|
|
|
/**
|
|
* The activator class controls the plug-in life cycle
|
|
*/
|
|
public class ShareClient extends AbstractUIPlugin implements MessageListener, DisconnectListener, IStartup {
|
|
|
|
// The plug-in ID
|
|
public static final String PLUGIN_ID = "ShareClient"; //$NON-NLS-1$
|
|
|
|
// The shared instance
|
|
private static ShareClient plugin;
|
|
|
|
private ShareClientPartListener partListener;
|
|
|
|
private ShareView view;
|
|
private ShareSession activeSession;
|
|
|
|
public ShareClient() {
|
|
|
|
}
|
|
|
|
@Override
|
|
public void start(BundleContext context) throws Exception {
|
|
super.start(context);
|
|
plugin = this;
|
|
partListener = new ShareClientPartListener();
|
|
|
|
getPreferenceStore().setDefault(ShareClientPreferences.SERVER_URI, "ws://localhost:5473");
|
|
getPreferenceStore().setDefault(ShareClientPreferences.SHOW_CURSORS, true);
|
|
// new ShareWSClient(URI.create("ws://localhost:5473")).connect();
|
|
|
|
PlatformUI.getWorkbench().addWindowListener(ShareClientWindowListener.INSTANCE);
|
|
Arrays.stream(PlatformUI.getWorkbench().getWorkbenchWindows()).forEach(w -> {
|
|
w.addPageListener(ShareClientPageListener.INSTANCE);
|
|
Arrays.stream(w.getPages()).forEach(p -> {
|
|
p.addPartListener(partListener);
|
|
Arrays.stream(p.getEditorReferences()).forEach(e -> partListener.addDocumentListener(e));
|
|
});
|
|
});
|
|
|
|
ResourcesPlugin.getWorkspace().addResourceChangeListener(event -> Display.getDefault().asyncExec(() -> handleChange(event.getDelta())), IResourceChangeEvent.POST_CHANGE);
|
|
// TODO: handle PRE_CLOSE events?
|
|
}
|
|
|
|
private void handleChange(IResourceDelta delta) {
|
|
ShareSession session = ShareClient.getDefault().getActiveSession();
|
|
if(session == null) return;
|
|
|
|
IResource resource = delta.getResource();
|
|
SharedProject project = session.getSharedProject(resource.getProject());
|
|
|
|
if(project != null) {
|
|
if(project.getSyncState() == SyncState.SYNCING) return; // Project is not done syncing, ignore local changes
|
|
|
|
switch(delta.getKind()) {
|
|
case IResourceDelta.ADDED -> {
|
|
if(resource instanceof IFile file) {
|
|
if(file.isDerived()) return;
|
|
|
|
Path filePath = file.getLocation().toPath();
|
|
ProjectAndPath path = getProjectAndPath(file);
|
|
ProjectRelativePath relativePath = new ProjectRelativePath(project.getRemoteName(), path.path());
|
|
SharedDocument document = session.getSharedDocument(relativePath);
|
|
if(document != null) {
|
|
// Shouldn't be the case
|
|
System.err.println("Resource was created but is already shared");
|
|
session.removeSharedDocument(relativePath); // Remove the existing shared document
|
|
}
|
|
|
|
try {
|
|
document = session.createSharedDocument(relativePath, Files.readAllBytes(filePath));
|
|
sendFullSyncOrChecksum(session.getConnection(), AddressableMessage.BROADCAST_SITE_ID, relativePath, filePath, false);
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
MessageDialog.openError(null, "Share Client", "Failed to update file: " + e.toString());
|
|
return;
|
|
}
|
|
}
|
|
|
|
System.out.println("ADDED " + delta.getResource() + " | Derived: " + delta.getResource().isDerived());
|
|
}
|
|
case IResourceDelta.REMOVED -> {
|
|
if(resource instanceof IFile file) {
|
|
if(file.isDerived()) return;
|
|
|
|
ProjectAndPath path = getProjectAndPath(file);
|
|
ProjectRelativePath relativePath = new ProjectRelativePath(project.getRemoteName(), path.path());
|
|
session.removeSharedDocument(relativePath);
|
|
|
|
// TODO: send delete message
|
|
}
|
|
|
|
System.out.println("REMOVED " + delta.getResource() + " | Derived: " + delta.getResource().isDerived());
|
|
}
|
|
case IResourceDelta.CHANGED -> /* TODO: check for (external) file changes? */ System.out.println("CHANGED " + delta.getResource() + " | Derived: " + delta.getResource().isDerived());
|
|
}
|
|
}
|
|
|
|
for(IResourceDelta child : delta.getAffectedChildren()) {
|
|
handleChange(child);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void stop(BundleContext context) throws Exception {
|
|
plugin = null;
|
|
super.stop(context);
|
|
}
|
|
|
|
/**
|
|
* Returns the shared instance
|
|
*
|
|
* @return the shared instance
|
|
*/
|
|
public static ShareClient getDefault() {
|
|
return plugin;
|
|
}
|
|
|
|
public void updateView() {
|
|
if (view == null) return;
|
|
Display.getDefault().asyncExec(() -> view.updateActionBars());
|
|
|
|
if (activeSession == null) return;
|
|
String[] peerNames = activeSession.getPeers().stream().map(p -> p.name()).toArray(String[]::new);
|
|
Display.getDefault().asyncExec(() -> view.getViewer().setInput(peerNames));
|
|
}
|
|
|
|
public ShareSession startSession(String sessionID) {
|
|
String serverURI = getPreferenceStore().getString(ShareClientPreferences.SERVER_URI);
|
|
if (serverURI == null) return null;
|
|
|
|
String username = getPreferenceStore().getString(ShareClientPreferences.USERNAME);
|
|
if (username == null || username.isBlank())
|
|
username = "user" + new Random().nextInt(1000);
|
|
|
|
WebSocketConnection connection = new WebSocketConnection(URI.create(serverURI), username);
|
|
try {
|
|
connection.connect(sessionID); // TODO: connect to existing session
|
|
} catch (ConnectionException e) {
|
|
e.printStackTrace();
|
|
MessageDialog.openError(null, "Share Client", "Failed to connect to server: " + e);
|
|
return null;
|
|
}
|
|
|
|
connection.addListener(this);
|
|
connection.setDisconnectListener(this);
|
|
|
|
updateView();
|
|
return activeSession = new ShareSession(connection, sessionID);
|
|
}
|
|
|
|
public ShareSession getOrStartSession() {
|
|
if (activeSession == null) {
|
|
startSession(UUID.randomUUID().toString());
|
|
}
|
|
|
|
return activeSession;
|
|
}
|
|
|
|
public void closeConnection() {
|
|
if (activeSession == null) return;
|
|
ShareSession session = activeSession;
|
|
activeSession = null;
|
|
session.stop();
|
|
updateView();
|
|
}
|
|
|
|
public ShareSession getActiveSession() {
|
|
return activeSession;
|
|
}
|
|
|
|
public void setView(ShareView view) {
|
|
this.view = view;
|
|
}
|
|
|
|
public ShareView getView() {
|
|
return view;
|
|
}
|
|
|
|
@Override
|
|
public void onMessage(Message message) {
|
|
Display.getDefault().asyncExec(() -> {
|
|
if (message instanceof PeerJoinMessage join) {
|
|
activeSession.getPeers().add(new Peer(join.peerName(), join.peerSiteID()));
|
|
updateView();
|
|
}
|
|
|
|
if(message instanceof PeerLeaveMessage leave) {
|
|
activeSession.getPeers().removeIf(p -> p.siteID() == leave.peerSiteID());
|
|
updateView();
|
|
}
|
|
|
|
if (message instanceof FullSyncMessage sync) {
|
|
ProjectRelativePath path;
|
|
try {
|
|
path = ProjectRelativePath.of(sync.documentPath());
|
|
} catch (IllegalArgumentException e) {
|
|
e.printStackTrace();
|
|
return;
|
|
}
|
|
|
|
ShareClientDocumentListener listener = partListener.getListener(path);
|
|
|
|
IWorkspace workspace = ResourcesPlugin.getWorkspace();
|
|
IWorkspaceRoot workspaceRoot = workspace.getRoot();
|
|
SharedProject sharedProject = activeSession.getSharedProject(path.projectName());
|
|
if(sharedProject == null) {
|
|
// New project, TODO: prompt user to choose location
|
|
IProject project = workspaceRoot.getProject(path.projectName());
|
|
if(project == null) return;
|
|
|
|
// TODO: make sure to not overwrite existing non-shared projects
|
|
if (!project.exists()) {
|
|
IProjectDescription description = workspace.newProjectDescription(path.projectName());
|
|
try {
|
|
project.create(description, null);
|
|
project.open(null);
|
|
} catch (CoreException e) {
|
|
e.printStackTrace();
|
|
MessageDialog.openError(null, "Share Client", "Failed to create project: " + e.toString());
|
|
return;
|
|
}
|
|
System.out.println("Created project: " + project);
|
|
}
|
|
|
|
sharedProject = new SharedProject(path.projectName(), project);
|
|
activeSession.getSharedProjects().add(sharedProject);
|
|
System.out.println("Received new project: " + path.projectName());
|
|
}
|
|
|
|
Path filePath = sharedProject.getLocal().getLocation().toPath().resolve(path.relativePath());
|
|
try {
|
|
if (!Files.exists(filePath)) {
|
|
Files.createDirectories(filePath.getParent());
|
|
Files.createFile(filePath);
|
|
}
|
|
|
|
byte[] bytes = new byte[sync.content().size()];
|
|
for(int i = 0; i < bytes.length; i++) {
|
|
bytes[i] = sync.content().get(i).value();
|
|
}
|
|
|
|
SharedDocument sharedDocument = activeSession.getOrCreateSharedDocument(path, null /* because the content will be replaced afterwards anyway */);
|
|
sharedDocument.clear();
|
|
for(Char c : sync.content()) sharedDocument.getCharBag().add(c);
|
|
|
|
if(listener != null) listener.setIgnoreChanges(true);
|
|
Files.write(filePath, bytes);
|
|
sharedProject.getLocal().refreshLocal(IResource.DEPTH_INFINITE, null);
|
|
if(listener != null) listener.setIgnoreChanges(false);
|
|
} catch (IOException | CoreException e) {
|
|
e.printStackTrace();
|
|
MessageDialog.openError(null, "Share Client", "Failed to update file: " + e.toString());
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (message instanceof RequestFullSyncMessage req) {
|
|
Map<ProjectRelativePath, Path> paths = new HashMap<>();
|
|
if (req.documentPath() == null) {
|
|
// Sync entire (shared) workspace
|
|
for (SharedProject project : activeSession.getSharedProjects()) {
|
|
var files = getProjectFiles(project);
|
|
if (files == null) return;
|
|
paths.putAll(files);
|
|
}
|
|
} else {
|
|
ProjectRelativePath path;
|
|
try {
|
|
path = ProjectRelativePath.of(req.documentPath());
|
|
} catch (IllegalArgumentException e) {
|
|
return;
|
|
}
|
|
|
|
SharedProject sharedProject = activeSession.getSharedProject(path.projectName());
|
|
if (sharedProject == null) return;
|
|
|
|
if (!path.relativePath().isEmpty()) {
|
|
Path projectLocation = sharedProject.getLocal().getLocation().toPath();
|
|
Path filePath = projectLocation.resolve(path.relativePath()).normalize();
|
|
if (!filePath.startsWith(projectLocation)) return;
|
|
paths.put(new ProjectRelativePath(sharedProject.getRemoteName(), path.relativePath()), filePath);
|
|
} else {
|
|
// Sync entire project
|
|
var files = getProjectFiles(sharedProject);
|
|
if (files == null) return;
|
|
paths.putAll(files);
|
|
}
|
|
}
|
|
|
|
RemoteConnection connection = activeSession.getConnection();
|
|
System.out.println(paths);
|
|
for (var en : paths.entrySet()) {
|
|
if(!sendFullSyncOrChecksum(connection, req.siteID(), en.getKey(), en.getValue(), false)) return;
|
|
}
|
|
}
|
|
|
|
if(message instanceof ChangeMessage change) {
|
|
ProjectRelativePath path;
|
|
try {
|
|
path = ProjectRelativePath.of(change.documentPath());
|
|
}catch(IllegalArgumentException e) {
|
|
return;
|
|
}
|
|
|
|
SharedDocument doc = activeSession.getSharedDocument(path); // Doesn't use getOrCreateSharedDocument, because it doesn't make sense to apply a change to a document that wasn't previously shared
|
|
|
|
if(doc == null) {
|
|
// TODO: show proper synchronization issue warning, because all received changes should be in previously shared documents
|
|
MessageDialog.openError(null, "Share Client", "Synchronization issue (received change in non-shared document)");
|
|
return;
|
|
}
|
|
|
|
doc.onMessage(message);
|
|
}
|
|
});
|
|
}
|
|
|
|
@Override
|
|
public void onDisconnect(String reason, boolean remote) {
|
|
MessageDialog.openError(null, "Share Client", "Disconnected (remote = " + remote + "): " + reason);
|
|
}
|
|
|
|
/**
|
|
* Shares a project. Includes sending full syncs to other clients
|
|
* @param project The project to share
|
|
*/
|
|
public void addSharedProject(IProject project) {
|
|
SharedProject shared = new SharedProject(activeSession.getFreeRemoteName(project.getName()), project);
|
|
activeSession.getSharedProjects().add(shared);
|
|
|
|
RemoteConnection connection = activeSession.getConnection();
|
|
for(Map.Entry<ProjectRelativePath, Path> en : getProjectFiles(shared).entrySet()) {
|
|
activeSession.getOrCreateSharedDocument(en.getKey(), () -> {
|
|
try {
|
|
return Files.readAllBytes(en.getValue());
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
throw new RuntimeException(e);
|
|
}
|
|
});
|
|
|
|
if(!sendFullSyncOrChecksum(connection, AddressableMessage.BROADCAST_SITE_ID, en.getKey(), en.getValue(), false)) return;
|
|
}
|
|
|
|
shared.setSyncState(SyncState.SYNCED);
|
|
}
|
|
|
|
private boolean sendFullSyncOrChecksum(RemoteConnection connection, int siteID, ProjectRelativePath relativePath, Path filePath, boolean checksum) {
|
|
if (!Files.isRegularFile(filePath)) return true;
|
|
|
|
try {
|
|
if(!checksum) {
|
|
SharedDocument document = activeSession.getSharedDocument(relativePath);
|
|
connection.send(new FullSyncMessage(siteID, relativePath.toString(), document.toList()));
|
|
}else {
|
|
byte[] bytes = Files.readAllBytes(filePath);
|
|
connection.send(new ChecksumMessage(siteID, relativePath.toString(), ChecksumUtil.generateSHA256(bytes)));
|
|
}
|
|
} catch (IOException | ConnectionException e) {
|
|
e.printStackTrace();
|
|
MessageDialog.openError(null, "Share Client", "Failed to send file contents: " + e.toString());
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private ProjectAndPath resolveToProjectAndPath(ProjectRelativePath path) {
|
|
SharedProject sharedProject = activeSession.getSharedProject(path.projectName());
|
|
if(sharedProject == null) return null;
|
|
return new ProjectAndPath(sharedProject.getLocal(), path.relativePath());
|
|
}
|
|
|
|
private Path resolveToPath(ProjectRelativePath path) {
|
|
SharedProject sharedProject = activeSession.getSharedProject(path.projectName());
|
|
if(sharedProject == null) return null;
|
|
Path projectLocation = sharedProject.getLocal().getLocation().toPath();
|
|
Path filePath = projectLocation.resolve(path.relativePath()).normalize();
|
|
if (!filePath.startsWith(projectLocation)) return null;
|
|
return filePath;
|
|
}
|
|
|
|
private ProjectAndPath getProjectAndPath(IFile file) {
|
|
IProject project = file.getProject();
|
|
Path projectLocation = project.getLocation().toPath();
|
|
return new ProjectAndPath(file.getProject(), projectLocation.relativize(file.getLocation().toPath()).toString());
|
|
}
|
|
|
|
private Map<ProjectRelativePath, Path> getProjectFiles(SharedProject project) {
|
|
try {
|
|
Path projectLocation = project.getLocal().getLocation().toPath();
|
|
return Files.walk(projectLocation)
|
|
.filter(Files::isRegularFile)
|
|
.collect(Collectors.toMap(
|
|
p -> new ProjectRelativePath(project.getRemoteName(), projectLocation.relativize(p).toString()),
|
|
Function.identity()));
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
MessageDialog.openError(null, "Share Client", "Failed to collect project files: " + e.toString());
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public ShareClientPartListener getPartListener() {
|
|
return partListener;
|
|
}
|
|
|
|
public static void assertOnUIThread() {
|
|
if(!Thread.currentThread().equals(Display.getDefault().getThread())) {
|
|
MessageDialog.openError(null, "Assertion failed", "Not on UI thread");
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void earlyStartup() {
|
|
}
|
|
|
|
}
|