|
1
23 package org.jlibrary.cache.impl;
24
25 import java.io.ByteArrayInputStream  ;
26 import java.io.IOException ;
27 import java.io.InputStream ;
28
29 import org.apache.commons.io.IOUtils;
30 import org.apache.commons.lang.StringUtils;
31 import org.eclipse.core.resources.IFile;
32 import org.eclipse.core.resources.IFolder;
33 import org.eclipse.core.resources.IProject;
34 import org.eclipse.core.resources.IResource;
35 import org.eclipse.core.resources.IWorkspace;
36 import org.eclipse.core.resources.IWorkspaceRoot;
37 import org.eclipse.core.resources.ResourcesPlugin;
38 import org.eclipse.core.runtime.CoreException;
39 import org.eclipse.core.runtime.NullProgressMonitor;
40 import org.jlibrary.client.cache.LocalCache;
41 import org.jlibrary.client.cache.LocalCacheException;
42 import org.jlibrary.core.entities.Node;
43 import org.jlibrary.core.entities.Repository;
44 import org.jlibrary.core.util.FileUtils;
45
46
47
62 public class WorkspaceCache implements LocalCache {
63
64 public WorkspaceCache() {
65
66 super();
67 System.out.println("[WorkspaceCache] Initializing workspace cache");
68 }
69
70
73 public void clearCache() throws LocalCacheException {
74
75 IWorkspace workspace = ResourcesPlugin.getWorkspace();
76 IWorkspaceRoot root = workspace.getRoot();
77
78 try {
79 IProject[] projects = root.getProjects();
80 for (int i = 0; i < projects.length; i++) {
81 projects[i].delete(true,true,null);
82 }
83 } catch (CoreException e) {
84 e.printStackTrace();
85 throw new LocalCacheException(e);
86 }
87 }
88
89
92 public void addNodeToCache(Node node,
93 byte[] content) throws LocalCacheException {
94
95 System.out.println("[WorkspaceCache] Adding node to cache: " + node.getName());
96 String repository = node.getRepository();
97 IWorkspace workspace = checkWorkspace(repository);
98 IProject project = workspace.getRoot().getProject(node.getRepository());
99 IFolder folder = checkFolder(project, node.getPath());
100 createFile(project,folder,node,content);
101 }
102
103
106 public void removeNodeFromCache(Node node) throws LocalCacheException {
107
108 IWorkspace workspace = ResourcesPlugin.getWorkspace();
109 IWorkspaceRoot root = workspace.getRoot();
110
111 String repository = node.getRepository();
112 IProject project = root.getProject(repository);
113 if (!project.exists()) {
114 return;
115 }
116 deleteFile(project,node);
117 }
118
119
120
121
124 public byte[] getNodeContent(Node node) throws LocalCacheException {
125
126 IWorkspace workspace = ResourcesPlugin.getWorkspace();
127 IWorkspaceRoot root = workspace.getRoot();
128
129 String repository = node.getRepository();
130 IProject project = root.getProject(repository);
131 if (!project.exists()) {
132 throw new LocalCacheException("Local project does not exist");
133 }
134 IFile file = getFile(project,node);
135
136 if (file == null) {
137 throw new LocalCacheException("The file cannot be found on local cache");
138 }
139
140 try {
141 file.refreshLocal(IResource.DEPTH_ZERO, null);
143
144 InputStream stream = file.getContents();
145 byte[] contents = IOUtils.toByteArray(stream);
146 stream.close();
147 return contents;
148 } catch (CoreException e) {
149 e.printStackTrace();
150 throw new LocalCacheException(e);
151 } catch (IOException e) {
152 e.printStackTrace();
153 throw new LocalCacheException(e);
154 }
155 }
156
157
160 public String getNodePath(Node node) throws LocalCacheException {
161
162 IWorkspace workspace = ResourcesPlugin.getWorkspace();
163 IWorkspaceRoot root = workspace.getRoot();
164
165 String repository = node.getRepository();
166 IProject project = root.getProject(repository);
167 if (!project.exists()) {
168 throw new LocalCacheException("Local project does not exist");
169 }
170 IFile file = getFile(project,node);
171 if (file == null) {
172 throw new LocalCacheException("The file cannot be found on local cache");
173 }
174
175 return file.getLocation().toFile().getAbsolutePath();
176 }
177
178
181 public boolean isNodeCached(Node node) throws LocalCacheException {
182
183 IWorkspace workspace = ResourcesPlugin.getWorkspace();
184 IWorkspaceRoot root = workspace.getRoot();
185
186 String repository = node.getRepository();
187 IProject project = root.getProject(repository);
188 if (!project.exists()) {
189 return false;
190 }
191 IFile file = getFile(project,node);
192 if ((file == null) || (!file.exists())) {
193 return false;
194 }
195 return true;
196 }
197
198
201 public void clearCache(Repository repository) throws LocalCacheException {
202
203 IWorkspace workspace = ResourcesPlugin.getWorkspace();
204 IWorkspaceRoot root = workspace.getRoot();
205
206 IProject project = root.getProject(repository.getId());
207 if (!project.exists()) {
208 throw new LocalCacheException("Local project does not exist");
209 }
210 try {
211 project.delete(true,true,null);
212 } catch (CoreException e) {
213 e.printStackTrace();
214 throw new LocalCacheException(e);
215 }
216 }
217
218 private IWorkspace checkWorkspace(String repository) throws LocalCacheException {
219
220 try {
221 IWorkspace workspace = ResourcesPlugin.getWorkspace();
222 IWorkspaceRoot root = workspace.getRoot();
223 IProject project = root.getProject(repository);
224 if (!project.exists()) {
225 project.create(new NullProgressMonitor());
226 }
227 if (!project.isOpen()) {
228 project.open(null);
229 }
230
231 return workspace;
232 } catch (CoreException e) {
233 e.printStackTrace();
234 throw new LocalCacheException(e);
235 }
236 }
237
238 private IFolder checkFolder(IProject project,
239 String path) throws LocalCacheException {
240
241 try {
242 IFolder folder = null;
243
244 String [] splittedPath = StringUtils.split(path,"/");
245 if (splittedPath.length > 1) {
246 for (int i = 0; i < splittedPath.length-1; i++) {
247 String folderName = splittedPath[i];
248 if (folder == null) {
249 folder = project.getFolder(folderName);
250 } else {
251 folder = folder.getFolder(folderName);
252 }
253 if (!folder.exists()) {
254 folder.create(IResource.NONE,true,null);
255 }
256 }
257 }
258
259 return folder;
260 } catch (CoreException e) {
261 e.printStackTrace();
262 throw new LocalCacheException(e);
263 }
264 }
265
266 private IFile createFile(IProject project,
267 IFolder folder,
268 Node node,
269 byte[] content) throws LocalCacheException {
270
271 try {
272 String filename = FileUtils.getFileName(node.getPath());
273 IFile file = null;
274 if (folder == null) {
275 file = project.getFile(filename);
276 } else {
277 file = folder.getFile(filename);
278 }
279
280 if (!file.exists()) {
281 InputStream source = new ByteArrayInputStream (content);
282 file.create(source, IResource.NONE, null);
283 }
284
285 return file;
286 } catch (CoreException e) {
287 e.printStackTrace();
288 throw new LocalCacheException(e);
289 }
290
291 }
292
293 private IFile getFile(IProject project,Node node) {
294
295 IFolder folder = null;
296
297 String [] splittedPath = StringUtils.split(node.getPath(),"/");
298 if (splittedPath.length > 1) {
299 for (int i = 0; i < splittedPath.length-1; i++) {
300 String folderName = splittedPath[i];
301 if (folder == null) {
302 folder = project.getFolder(folderName);
303 } else {
304 folder = folder.getFolder(folderName);
305 }
306 if (!folder.exists()) {
307 return null;
308 }
309 }
310 }
311
312 String filename = FileUtils.getFileName(node.getPath());
313 IFile file = null;
314 if (folder == null) {
315 file = project.getFile(filename);
316 } else {
317 file = folder.getFile(filename);
318 }
319
320 if (!file.exists()) {
321 return null;
322 }
323
324 return file;
325 }
326
327 private void deleteFile(IProject project,
328 Node node) throws LocalCacheException {
329
330 IFile file = getFile(project,node);
331 if ((file == null) || !file.exists()) {
332 return;
333 }
334 try {
335 file.delete(true,null);
336 } catch (CoreException e) {
337 e.printStackTrace();
338 throw new LocalCacheException(e);
339 }
340 }
341
342
349 public IFile getFile(Node node) throws LocalCacheException {
350
351 IWorkspace workspace = ResourcesPlugin.getWorkspace();
352 IWorkspaceRoot root = workspace.getRoot();
353
354 String repository = node.getRepository();
355 IProject project = root.getProject(repository);
356 if (!project.exists()) {
357 throw new LocalCacheException("Local project does not exist");
358 }
359 IFile file = getFile(project,node);
360 if (file == null) {
361 throw new LocalCacheException("The file cannot be found on local cache");
362 }
363
364 return file;
365 }
366 }
367 |
Popular Tags |
Java API By Example, From Geeks To Geeks.