1 files changed, 326 insertions, 0 deletions

diff --git a/plugins/org.yocto.bc.ui/src/org/yocto/bc/ui/model/YoctoHostFile.java b/plugins/org.yocto.bc.ui/src/org/yocto/bc/ui/model/YoctoHostFile.java
new file mode 100644
index 0000000..7113efb
--- /dev/null
+++ b/plugins/org.yocto.bc.ui/src/org/yocto/bc/ui/model/YoctoHostFile.java
@@ -0,0 +1,326 @@
+/*******************************************************************************
+ * Copyright (c) 2013 Intel Corporation.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Ioana Grigoropol(Intel) - initial API and implementation
+ *******************************************************************************/
+package org.yocto.bc.ui.model;
+
+import java.io.File;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.ArrayList;
+
+import org.eclipse.core.filesystem.EFS;
+import org.eclipse.core.filesystem.IFileInfo;
+import org.eclipse.core.filesystem.IFileStore;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.osgi.util.NLS;
+import org.eclipse.rse.core.model.IHost;
+import org.eclipse.rse.services.clientserver.messages.SystemMessageException;
+import org.eclipse.rse.services.files.IFileService;
+import org.eclipse.rse.services.files.IHostFile;
+import org.yocto.bc.ui.filesystem.Messages;
+import org.yocto.bc.ui.filesystem.OEFile;
+import org.yocto.bc.ui.filesystem.Policy;
+import org.yocto.remote.utils.RemoteHelper;
+
+public class YoctoHostFile implements IHostFile{
+        private IHostFile file;
+        private final URI fileURI;
+        private ProjectInfo projectInfo;
+        private IFileService fileService;
+
+        public YoctoHostFile(ProjectInfo pInfo, URI fileURI, IProgressMonitor monitor) throws SystemMessageException {
+                this.projectInfo = pInfo;
+                this.fileURI = fileURI;
+                String path = fileURI.getPath();
+                fileService = projectInfo.getFileService(monitor);
+                file = RemoteHelper.getRemoteHostFile(projectInfo.getConnection(), path, monitor);
+        }
+
+        public YoctoHostFile(ProjectInfo projectInfo, URI uri) {
+                this.fileURI = uri;
+                this.projectInfo = projectInfo;
+        }
+
+        public IHostFile getFile() {
+                return file;
+        }
+        public void setFile(IHostFile file) {
+                this.file = file;
+        }
+        public ProjectInfo getProjectInfo() {
+                return projectInfo;
+        }
+        public void setProjectInfo(ProjectInfo projectInfo) {
+                this.projectInfo = projectInfo;
+        }
+        @Override
+        public String getAbsolutePath() {
+                return file.getAbsolutePath();
+        }
+        @Override
+        public String getName() {
+                return file.getName();
+        }
+        public URI getProjectLocationURI() {
+                return projectInfo.getOriginalURI();
+        }
+        public URI getLocationURI() {
+                projectInfo.getOriginalURI().getPath().indexOf(file.getAbsolutePath());
+                return projectInfo.getOriginalURI();
+        }
+        @Override
+        public boolean isDirectory() {
+                return file.isDirectory();
+        }
+        @Override
+        public String getParentPath() {
+                return file.getParentPath();
+        }
+        public boolean copy(IFileStore destFileStore, IProgressMonitor monitor) {
+                IHostFile destFile;
+                try {
+                        OEFile oeFile = (OEFile)destFileStore;
+                        String parentPath = oeFile.getParentPath();
+                        destFile = fileService.createFile(parentPath, destFileStore.getName(), monitor);
+                        fileService.copy(file.getParentPath(), file.getName(), destFile.getParentPath(), destFile.getName(), monitor);
+                } catch (SystemMessageException e) {
+                        e.printStackTrace();
+                        return false;
+                }
+                return true;
+        }
+        @Override
+        public boolean exists() {
+                return file.exists();
+        }
+        @Override
+        public boolean canRead() {
+                return file.canRead();
+        }
+        @Override
+        public boolean canWrite() {
+                return file.canWrite();
+        }
+        @Override
+        public long getModifiedDate() {
+                return file.getModifiedDate();
+        }
+        @Override
+        public long getSize() {
+                return file.getSize();
+        }
+        @Override
+        public boolean isArchive() {
+                return file.isArchive();
+        }
+        @Override
+        public boolean isFile() {
+                return file.isFile();
+        }
+        @Override
+        public boolean isHidden() {
+                return file.isHidden();
+        }
+        @Override
+        public boolean isRoot() {
+                return file.isRoot();
+        }
+        @Override
+        public void renameTo(String newName) {
+                file.renameTo(newName);
+        }
+        public URI getParentFile() {
+                if (file.getParentPath().isEmpty())
+                        return null;
+                try {
+                        return new URI(fileURI.getScheme(), fileURI.getHost(), file.getParentPath(), fileURI.getFragment());
+                } catch (URISyntaxException e) {
+                        e.printStackTrace();
+                        return null;
+                }
+        }
+        public boolean delete(IProgressMonitor monitor) {
+                try {
+                        fileService.delete(file.getParentPath(), file.getName(), monitor);
+                } catch (SystemMessageException e) {
+                        e.printStackTrace();
+                        return false;
+                }
+                return true;
+        }
+
+        /**
+         * This method is called after a failure to modify a file or directory.
+         * Check to see if the parent is read-only and if so then
+         * throw an exception with a more specific message and error code.
+         *
+         * @param target The file that we failed to modify
+         * @param exception The low level exception that occurred, or <code>null</code>
+         * @throws CoreException A more specific exception if the parent is read-only
+         */
+        private void checkReadOnlyParent() throws CoreException {
+                String parent = file.getParentPath();
+                String parentOfParent = parent.substring(0, parent.lastIndexOf("/"));
+                IHostFile parentFile;
+                try {
+                        parentFile = fileService.getFile(parentOfParent, parent, new NullProgressMonitor());
+                        if (parentFile == null || !parentFile.canRead() || !parentFile.canWrite()) {
+                                String message = NLS.bind(Messages.readOnlyParent, parent);
+                                Policy.error(EFS.ERROR_PARENT_READ_ONLY, message, null);
+                        }
+                } catch (SystemMessageException e) {
+                        e.printStackTrace();
+                }
+
+        }
+
+        public void mkdir(int options) {
+                try {
+
+                        if (!file.isDirectory()) {
+                                file = fileService.createFolder(file.getParentPath(), file.getName(), new NullProgressMonitor());
+                                if (!file.isDirectory()) {
+                                        checkReadOnlyParent();
+                                        String message = NLS.bind(Messages.failedCreateWrongType, file.getAbsolutePath());
+                                        Policy.error(EFS.ERROR_WRONG_TYPE, message);
+                                }
+                        }
+                } catch (SystemMessageException e1) {
+                        e1.printStackTrace();
+                } catch (CoreException e) {
+                        e.printStackTrace();
+                }
+
+        }
+
+        public String[] getChildNames(IProgressMonitor monitor) {
+                if (file.isDirectory()) {
+                        IHostFile[] files;
+                        try {
+                                files = fileService.list(file.getAbsolutePath(), "*", IFileService.FILE_TYPE_FILES_AND_FOLDERS, monitor);
+                                ArrayList<String> names = new ArrayList<String>();
+
+                                for (IHostFile f : files) {
+                                        names.add(f.getName());
+                                }
+
+                                String[] arrNames = new String[names.size()];
+                                names.toArray(arrNames);
+                                return arrNames;
+                        } catch (SystemMessageException e) {
+                                e.printStackTrace();
+                        }
+                }
+                return  new String[]{};
+        }
+        public IHost getConnection() {
+                return projectInfo.getConnection();
+        }
+
+        public URI getChildURI(String name) {
+                try {
+                        return new URI(fileURI.getScheme(), fileURI.getHost(), fileService.getFile(file.getAbsolutePath(), name, null).getAbsolutePath(), fileURI.getFragment());
+                } catch (URISyntaxException e) {
+                        e.printStackTrace();
+                } catch (SystemMessageException e) {
+                        e.printStackTrace();
+                }
+                return null;
+        }
+        public File toLocalFile() {
+                //TODO
+                //fileService.getFile(file.getParentPath(), file.getName(), null);
+                return null;
+        }
+        public URI toURI() {
+                return fileURI;
+        }
+        public YoctoHostFile getChildHostFile(String name) {
+                try {
+                        return new YoctoHostFile(projectInfo, getChildURI(name), new NullProgressMonitor());
+                } catch (SystemMessageException e) {
+                        e.printStackTrace();
+                        return null;
+                }
+        }
+
+        public URI getChildURIformPath(IPath path) {
+                try {
+                        String fileName =  path.lastSegment();
+                        path = path.removeLastSegments(1);
+                        String newPath = fileService.getFile(file.getAbsolutePath() + "/" + path.toPortableString(), fileName, null).getAbsolutePath();
+                        return new URI(fileURI.getScheme(), fileURI.getHost(), newPath, fileURI.getFragment());
+                } catch (URISyntaxException e) {
+                        e.printStackTrace();
+                        return null;
+                } catch (SystemMessageException e) {
+                        e.printStackTrace();
+                        return null;
+                }
+        }
+
+        public void move(IFileStore destFile, IProgressMonitor monitor) {
+                try {
+                        fileService.move(file.getParentPath(), file.getName(), destFile.getParent().toURI().getPath(), destFile.getName(), monitor);
+                } catch (SystemMessageException e) {
+                        e.printStackTrace();
+                }
+        }
+
+        public OutputStream getOutputStream(int options, IProgressMonitor monitor) {
+                try {
+                        return fileService.getOutputStream(file.getParentPath(), file.getName(), options, monitor);
+                } catch (SystemMessageException e) {
+                        e.printStackTrace();
+                        return null;
+                }
+        }
+
+        public InputStream getInputStream(int options, IProgressMonitor monitor) {
+                try {
+                        return fileService.getInputStream(file.getParentPath(), file.getName(), false, monitor);
+                } catch (SystemMessageException e) {
+                        e.printStackTrace();
+                        return null;
+                }
+        }
+
+        public void putInfo(IFileInfo info, int options, IProgressMonitor monitor) {
+                try {
+                        if ((options & EFS.SET_LAST_MODIFIED) != 0)
+                                fileService.setLastModified(file.getParentPath(), file.getName(), info.getLastModified(), monitor);
+                } catch (SystemMessageException e) {
+                        e.printStackTrace();
+                }
+        }
+
+        public IFileService getFileService() {
+                return fileService;
+        }
+
+        public void setFileService(IFileService fileService) {
+                this.fileService = fileService;
+        }
+
+        @Override
+        public String toString() {
+                URI uri = this.projectInfo.getOriginalURI();
+                try {
+                        return new URI(uri.getScheme(), uri.getHost(), fileURI.getPath(), uri.getFragment()).toString();
+                } catch (URISyntaxException e) {
+                        return fileURI.toString();
+                }
+        }
+}