001: /**
002: * LibreSource
003: * Copyright (C) 2004-2008 Artenum SARL / INRIA
004: * http://www.libresource.org - contact@artenum.com
005: *
006: * This file is part of the LibreSource software,
007: * which can be used and distributed under license conditions.
008: * The license conditions are provided in the LICENSE.TXT file
009: * at the root path of the packaging that enclose this file.
010: * More information can be found at
011: * - http://dev.libresource.org/home/license
012: *
013: * Initial authors :
014: *
015: * Guillaume Bort / INRIA
016: * Francois Charoy / Universite Nancy 2
017: * Julien Forest / Artenum
018: * Claude Godart / Universite Henry Poincare
019: * Florent Jouille / INRIA
020: * Sebastien Jourdain / INRIA / Artenum
021: * Yves Lerumeur / Artenum
022: * Pascal Molli / Universite Henry Poincare
023: * Gerald Oster / INRIA
024: * Mariarosa Penzi / Artenum
025: * Gerard Sookahet / Artenum
026: * Raphael Tani / INRIA
027: *
028: * Contributors :
029: *
030: * Stephane Bagnier / Artenum
031: * Amadou Dia / Artenum-IUP Blois
032: * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
033: */package org.libresource.so6.web.servlet;
034:
035: import org.libresource.Libresource;
036:
037: import org.libresource.core.FileData;
038: import org.libresource.core.FileDataImpl;
039:
040: import org.libresource.kernel.LibresourceSecurityException;
041:
042: import org.libresource.so6.core.engine.util.InfoPatchHandler;
043: import org.libresource.so6.server.ls.InvalideTicketException;
044: import org.libresource.so6.server.ls.PatchBean;
045: import org.libresource.so6.server.ls.ejb.LibresourceSynchronizerServiceBean;
046: import org.libresource.so6.server.ls.interfaces.LibresourceSynchronizerService;
047:
048: import java.io.File;
049: import java.io.FileOutputStream;
050: import java.io.IOException;
051: import java.io.InputStream;
052: import java.io.OutputStream;
053: import java.io.Writer;
054:
055: import java.lang.reflect.Method;
056:
057: import java.net.URI;
058:
059: import java.util.Enumeration;
060:
061: import javax.servlet.ServletException;
062: import javax.servlet.http.HttpServletRequest;
063: import javax.servlet.http.HttpServletResponse;
064:
065: import javax.xml.parsers.SAXParser;
066: import javax.xml.parsers.SAXParserFactory;
067:
068: /**
069: * @author smack
070: */
071: public class So6Actions {
072: // Internal parameters
073: private static int BUFFER_SIZE = 1024 * 1024 * 2;
074:
075: // header props
076: protected final static String SO6_PATCH_TICKET = "so6.patch.ticket";
077: protected final static String SO6_PATCH_FROM_TICKET = "so6.patch.from.ticket";
078: protected final static String SO6_PATCH_TO_TICKET = "so6.patch.to.ticket";
079: protected final static String SO6_BIN_EXT = "so6.bin.ext";
080: protected final static String SO6_BASELINE_TICKET = "so6.baseline.ticket";
081: protected final static String SO6_BASELINE_FROM_TICKET = "so6.baseline.ticket.from";
082: protected final static String SO6_BASELINE_TO_TICKET = "so6.baseline.ticket.to";
083: protected final static String SO6_BASELINE_NAME = "so6.baseline.name";
084: protected final static String SO6_VALIDATE_TICKET_NUMBER = "so6.validate.ticket.number";
085:
086: //
087: public final static String SO6_SYNCHRONIZER_URI = "so6.synchronizer.uri";
088: public final static String SO6_REPLICA_URI = "so6.replica.uri";
089: public final static String SO6_REPLICA_NAME = "so6.replica.name";
090: public final static String SO6_REPLICA_PATH = "so6.replica.path";
091: public final static String SO6_REPLICA_TICKET = "so6.replica.ticket";
092:
093: //
094: public final static String SO6_WORKSPACE_ID = "so6.ws.id";
095: public final static String SO6_QUEUE_IDS = "so6.queue.ids";
096: public final static String SO6_QUEUE_ID = "so6.queue.id";
097: public final static String SO6_WSC_PATH = "so6.wsc.path";
098: public final static String SO6_WS_NAME = "so6.ws.name";
099: public final static int STATUS_CODE_AUTH_ERROR = 402;
100: public final static int STATUS_CODE_SERVER_ERROR = 403;
101: public final static int STATUS_CODE_INVALIDE_TICKET = 404;
102: public final static int STATUS_CODE_PATCH_NOT_FOUND = 405;
103:
104: public void runMethode(String action, HttpServletRequest request,
105: HttpServletResponse response) throws Exception {
106: // System.out.println(action);
107: Method m = this .getClass().getMethod(
108: action,
109: new Class[] { HttpServletRequest.class,
110: HttpServletResponse.class });
111: m.invoke(this , new Object[] { request, response });
112: }
113:
114: public void getPatch(HttpServletRequest request,
115: HttpServletResponse response) throws ServletException,
116: IOException {
117: showHeaderParam("getPatch", new String[] {
118: SO6_SYNCHRONIZER_URI, SO6_PATCH_TICKET }, request);
119:
120: String queueId = request.getHeader(SO6_SYNCHRONIZER_URI);
121: int ticket = Integer.parseInt(request
122: .getHeader(SO6_PATCH_TICKET));
123:
124: if (queueId.indexOf(",") != -1) {
125: queueId = queueId.substring(0, queueId.indexOf(","));
126: }
127:
128: try {
129: LibresourceSynchronizerService synchronizerService = (LibresourceSynchronizerService) Libresource
130: .getService("LibresourceSynchronizer");
131: FileData file = synchronizerService.getPatch(new URI(
132: queueId), ticket);
133:
134: // build response
135: response.setHeader("patchName", file.getName());
136: response.setHeader("Content-Length", Long.toString(file
137: .getSize()));
138:
139: InputStream is = file.getInputStream();
140: OutputStream os = response.getOutputStream();
141: int length;
142: byte[] buffer = new byte[BUFFER_SIZE];
143:
144: while ((length = is.read(buffer)) != -1) {
145: os.write(buffer, 0, length);
146: }
147:
148: os.flush();
149: os.close();
150: is.close();
151: } catch (LibresourceSecurityException e) {
152: response.sendError(STATUS_CODE_AUTH_ERROR);
153: } catch (InvalideTicketException e) {
154: response.sendError(STATUS_CODE_PATCH_NOT_FOUND);
155: } catch (Exception e) {
156: e.printStackTrace();
157: response.sendError(STATUS_CODE_SERVER_ERROR);
158: }
159: }
160:
161: public void getPatch2(HttpServletRequest request,
162: HttpServletResponse response) throws ServletException,
163: IOException {
164: showHeaderParam("getPatch2", new String[] {
165: SO6_SYNCHRONIZER_URI, SO6_PATCH_FROM_TICKET,
166: SO6_PATCH_TO_TICKET }, request);
167:
168: String queueId = request.getHeader(SO6_SYNCHRONIZER_URI);
169: long fromTicket = Long.parseLong(request
170: .getHeader(SO6_PATCH_FROM_TICKET));
171: long toTicket = Long.parseLong(request
172: .getHeader(SO6_PATCH_TO_TICKET));
173:
174: if (queueId.indexOf(",") != -1) {
175: queueId = queueId.substring(0, queueId.indexOf(","));
176: }
177:
178: try {
179: LibresourceSynchronizerService synchronizerService = (LibresourceSynchronizerService) Libresource
180: .getService("LibresourceSynchronizer");
181: FileData file = synchronizerService.getPatch(new URI(
182: queueId), fromTicket, toTicket);
183:
184: // build response
185: response.setHeader("patchName", file.getName());
186: response.setHeader("Content-Length", Long.toString(file
187: .getSize()));
188:
189: InputStream is = file.getInputStream();
190: OutputStream os = response.getOutputStream();
191: int length;
192: byte[] buffer = new byte[BUFFER_SIZE];
193:
194: while ((length = is.read(buffer)) != -1) {
195: os.write(buffer, 0, length);
196: }
197:
198: os.flush();
199: os.close();
200: is.close();
201: } catch (LibresourceSecurityException e) {
202: response.sendError(STATUS_CODE_AUTH_ERROR);
203: } catch (InvalideTicketException e) {
204: response.sendError(STATUS_CODE_PATCH_NOT_FOUND);
205: } catch (Exception e) {
206: e.printStackTrace();
207: response.sendError(STATUS_CODE_SERVER_ERROR);
208: }
209: }
210:
211: public void sendPatch(HttpServletRequest request,
212: HttpServletResponse response) throws ServletException,
213: IOException {
214: showHeaderParam("sendPatch", new String[] {
215: SO6_SYNCHRONIZER_URI, SO6_PATCH_FROM_TICKET,
216: SO6_PATCH_TO_TICKET, SO6_VALIDATE_TICKET_NUMBER },
217: request);
218:
219: String queueId = request.getHeader(SO6_SYNCHRONIZER_URI);
220: int fromTicket = Integer.parseInt(request
221: .getHeader(SO6_PATCH_FROM_TICKET));
222: int toTicket = Integer.parseInt(request
223: .getHeader(SO6_PATCH_TO_TICKET));
224:
225: boolean validateTicketNumber = true;
226:
227: if (request.getHeader(SO6_VALIDATE_TICKET_NUMBER) != null) {
228: validateTicketNumber = (request
229: .getHeader(SO6_VALIDATE_TICKET_NUMBER))
230: .equalsIgnoreCase("true");
231: }
232:
233: if (queueId.indexOf(",") != -1) {
234: queueId = queueId.substring(0, queueId.indexOf(","));
235: }
236:
237: // int responseStatus =
238: // Integer.parseInt(request.getHeader("ResponseStatus"));
239: try {
240: LibresourceSynchronizerService synchronizerService = (LibresourceSynchronizerService) Libresource
241: .getService("LibresourceSynchronizer");
242:
243: File baseDir = new File(LibresourceSynchronizerServiceBean
244: .getDistributedFileSystem(), "syncTmp");
245: baseDir.mkdirs();
246:
247: File tmpFile = File.createTempFile("sendPatch", null,
248: baseDir);
249:
250: // read request
251: InputStream is = request.getInputStream();
252: FileOutputStream fos = new FileOutputStream(tmpFile);
253: int length;
254: byte[] buffer = new byte[BUFFER_SIZE];
255:
256: while ((length = is.read(buffer)) != -1) {
257: fos.write(buffer, 0, length);
258: }
259:
260: fos.flush();
261: fos.close();
262: is.close();
263:
264: //
265: SAXParserFactory factory = SAXParserFactory.newInstance();
266: SAXParser saxParser = factory.newSAXParser();
267: InfoPatchHandler infoPatch = new InfoPatchHandler();
268: saxParser.parse(tmpFile, infoPatch);
269:
270: StringBuffer changeLog = new StringBuffer();
271:
272: for (Enumeration e = infoPatch.getFileIndex().keys(); e
273: .hasMoreElements();) {
274: changeLog.append(e.nextElement() + "\n");
275: }
276:
277: //
278: synchronizerService.addPatch(new URI(queueId), fromTicket,
279: toTicket, new FileDataImpl(tmpFile), infoPatch
280: .getWsName(), infoPatch.getComment(),
281: System.currentTimeMillis(), validateTicketNumber,
282: changeLog.toString());
283:
284: tmpFile.delete();
285: response.setStatus(202);
286: } catch (LibresourceSecurityException e) {
287: e.printStackTrace();
288: response.sendError(STATUS_CODE_AUTH_ERROR);
289: } catch (InvalideTicketException e) {
290: e.printStackTrace();
291: response.sendError(STATUS_CODE_PATCH_NOT_FOUND);
292: } catch (Exception e) {
293: e.printStackTrace();
294: response.sendError(STATUS_CODE_SERVER_ERROR);
295: }
296: }
297:
298: public void addBinExt(HttpServletRequest request,
299: HttpServletResponse response) throws ServletException,
300: IOException {
301: showHeaderParam("addBinExt", new String[] {
302: SO6_SYNCHRONIZER_URI, SO6_BIN_EXT }, request);
303:
304: try {
305: String queueId = request.getHeader(SO6_SYNCHRONIZER_URI);
306:
307: if (queueId.indexOf(",") != -1) {
308: queueId = queueId.substring(0, queueId.indexOf(","));
309: }
310:
311: String ext = request.getParameter(SO6_BIN_EXT);
312: LibresourceSynchronizerService synchronizerService = (LibresourceSynchronizerService) Libresource
313: .getService("LibresourceSynchronizer");
314: synchronizerService.addBinExt(new URI(queueId), ext);
315: } catch (LibresourceSecurityException e) {
316: response.sendError(STATUS_CODE_AUTH_ERROR);
317: } catch (Exception e) {
318: e.printStackTrace();
319: response.sendError(STATUS_CODE_SERVER_ERROR);
320: }
321: }
322:
323: public void removeBinExt(HttpServletRequest request,
324: HttpServletResponse response) throws ServletException,
325: IOException {
326: showHeaderParam("removeBinExt", new String[] {
327: SO6_SYNCHRONIZER_URI, SO6_BIN_EXT }, request);
328:
329: try {
330: String queueId = request.getHeader(SO6_SYNCHRONIZER_URI);
331:
332: if (queueId.indexOf(",") != -1) {
333: queueId = queueId.substring(0, queueId.indexOf(","));
334: }
335:
336: String ext = request.getParameter(SO6_BIN_EXT);
337: LibresourceSynchronizerService synchronizerService = (LibresourceSynchronizerService) Libresource
338: .getService("LibresourceSynchronizer");
339: synchronizerService.removeBinExt(new URI(queueId), ext);
340: } catch (LibresourceSecurityException e) {
341: response.sendError(STATUS_CODE_AUTH_ERROR);
342: } catch (Exception e) {
343: e.printStackTrace();
344: response.sendError(STATUS_CODE_SERVER_ERROR);
345: }
346: }
347:
348: public void getBinExt(HttpServletRequest request,
349: HttpServletResponse response) throws ServletException,
350: IOException {
351: showHeaderParam("getBinExt",
352: new String[] { SO6_SYNCHRONIZER_URI }, request);
353:
354: try {
355: String queueId = request.getHeader(SO6_SYNCHRONIZER_URI);
356:
357: if (queueId.indexOf(",") != -1) {
358: queueId = queueId.substring(0, queueId.indexOf(","));
359: }
360:
361: LibresourceSynchronizerService synchronizerService = (LibresourceSynchronizerService) Libresource
362: .getService("LibresourceSynchronizer");
363: String ext = synchronizerService
364: .getBinExt(new URI(queueId));
365: response.setContentLength(ext.length());
366: response.getWriter().write(ext);
367: response.getWriter().flush();
368: } catch (LibresourceSecurityException e) {
369: response.sendError(STATUS_CODE_AUTH_ERROR);
370: } catch (Exception e) {
371: e.printStackTrace();
372: response.sendError(STATUS_CODE_SERVER_ERROR);
373: }
374: }
375:
376: public void listPatch(HttpServletRequest request,
377: HttpServletResponse response) throws ServletException,
378: IOException {
379: showHeaderParam("listPatch",
380: new String[] { SO6_SYNCHRONIZER_URI }, request);
381:
382: try {
383: String queueId = request.getHeader(SO6_SYNCHRONIZER_URI);
384:
385: if (queueId.indexOf(",") != -1) {
386: queueId = queueId.substring(0, queueId.indexOf(","));
387: }
388:
389: LibresourceSynchronizerService synchronizerService = (LibresourceSynchronizerService) Libresource
390: .getService("LibresourceSynchronizer");
391: PatchBean[] patches = synchronizerService
392: .listSynchronizerPatch(new URI(queueId), -1);
393: StringBuffer buffer = new StringBuffer();
394: Writer out = response.getWriter();
395:
396: for (int i = 0; i < patches.length; i++) {
397: out.write(Long.toString(patches[i].getFromTicket()));
398: out.write(" ");
399: out.write(Long.toString(patches[i].getToTicket()));
400: out.write(" ");
401: out.write(Long.toString(patches[i].getPatchSize()));
402: out.write("\n");
403: }
404:
405: out.flush();
406: } catch (LibresourceSecurityException e) {
407: response.sendError(STATUS_CODE_AUTH_ERROR);
408: } catch (Exception e) {
409: e.printStackTrace();
410: response.sendError(STATUS_CODE_SERVER_ERROR);
411: }
412: }
413:
414: // DataflowClientI
415: public void createWorkspace(HttpServletRequest request,
416: HttpServletResponse response) throws ServletException,
417: IOException {
418: showHeaderParam("createWS", new String[] { SO6_WORKSPACE_ID },
419: request);
420:
421: try {
422: String wsId = request.getHeader(SO6_WORKSPACE_ID);
423: LibresourceSynchronizerService synchronizerService = (LibresourceSynchronizerService) Libresource
424: .getService("LibresourceSynchronizer");
425: synchronizerService.createWorkspace(wsId);
426: } catch (Exception e) {
427: e.printStackTrace();
428: response.sendError(STATUS_CODE_SERVER_ERROR);
429: }
430: }
431:
432: public void removeWorkspace(HttpServletRequest request,
433: HttpServletResponse response) throws ServletException,
434: IOException {
435: showHeaderParam("removeWs", new String[] { SO6_WORKSPACE_ID },
436: request);
437:
438: try {
439: String wsId = request.getHeader(SO6_WORKSPACE_ID);
440: LibresourceSynchronizerService synchronizerService = (LibresourceSynchronizerService) Libresource
441: .getService("LibresourceSynchronizer");
442: synchronizerService.removeWorkspace(wsId);
443: } catch (Exception e) {
444: e.printStackTrace();
445: response.sendError(STATUS_CODE_SERVER_ERROR);
446: }
447: }
448:
449: public void notifyWorkspaceConnections(HttpServletRequest request,
450: HttpServletResponse response) throws ServletException,
451: IOException {
452: showHeaderParam("notify", new String[] { SO6_WORKSPACE_ID,
453: SO6_QUEUE_IDS }, request);
454:
455: try {
456: String wsId = request.getHeader(SO6_WORKSPACE_ID);
457: String[] queueIds = request.getHeader(SO6_QUEUE_IDS).split(
458: " ");
459: LibresourceSynchronizerService synchronizerService = (LibresourceSynchronizerService) Libresource
460: .getService("LibresourceSynchronizer");
461: synchronizerService.updateWorkspaceConnections(wsId,
462: queueIds);
463: } catch (Exception e) {
464: e.printStackTrace();
465: response.sendError(STATUS_CODE_SERVER_ERROR);
466: }
467: }
468:
469: public void addWsConnection(HttpServletRequest request,
470: HttpServletResponse response) throws ServletException,
471: IOException {
472: showHeaderParam("addWsc", new String[] { SO6_WORKSPACE_ID,
473: SO6_SYNCHRONIZER_URI, SO6_WSC_PATH, SO6_WS_NAME },
474: request);
475:
476: try {
477: String wsId = request.getHeader(SO6_WORKSPACE_ID);
478: String queueId = request.getHeader(SO6_SYNCHRONIZER_URI);
479: String wscPath = request.getHeader(SO6_WSC_PATH);
480: String wsName = request.getHeader(SO6_WS_NAME);
481:
482: // vieux hack !!! for proxy bugs
483: if (queueId.indexOf(", ") != -1) {
484: queueId = queueId.substring(0, queueId.indexOf(", "));
485: }
486:
487: /*
488: * System.out.println("wsId: " + wsId); System.out.println("queueId: " +
489: * queueId); System.out.println("wscPath: " + wscPath);
490: * System.out.println("wsName: " + wsName);
491: */
492: LibresourceSynchronizerService synchronizerService = (LibresourceSynchronizerService) Libresource
493: .getService("LibresourceSynchronizer");
494: response.getWriter().write(
495: synchronizerService.createWorkspaceConnection(
496: new URI(queueId), wsId, wsName, wscPath));
497: } catch (LibresourceSecurityException e) {
498: response.sendError(STATUS_CODE_AUTH_ERROR);
499: } catch (Exception e) {
500: e.printStackTrace();
501: response.sendError(STATUS_CODE_SERVER_ERROR);
502: }
503: }
504:
505: public void removeWsConnection(HttpServletRequest request,
506: HttpServletResponse response) throws ServletException,
507: IOException {
508: showHeaderParam("removeWsc", new String[] { SO6_WORKSPACE_ID,
509: SO6_QUEUE_ID }, request);
510:
511: try {
512: String wsId = request.getHeader(SO6_WORKSPACE_ID);
513: String queueId = request.getHeader(SO6_QUEUE_ID);
514: LibresourceSynchronizerService synchronizerService = (LibresourceSynchronizerService) Libresource
515: .getService("LibresourceSynchronizer");
516: synchronizerService.deleteWorkspaceConnection(new URI(
517: queueId), wsId);
518: } catch (LibresourceSecurityException e) {
519: response.sendError(STATUS_CODE_AUTH_ERROR);
520: } catch (Exception e) {
521: e.printStackTrace();
522: response.sendError(STATUS_CODE_SERVER_ERROR);
523: }
524: }
525:
526: // DataflowReaderClientI
527: public void getNetworkFromWorkspace(HttpServletRequest request,
528: HttpServletResponse response) throws ServletException,
529: IOException {
530: showHeaderParam("getNetFromWs",
531: new String[] { SO6_WORKSPACE_ID }, request);
532:
533: try {
534: String wsId = request.getHeader(SO6_WORKSPACE_ID);
535: LibresourceSynchronizerService synchronizerService = (LibresourceSynchronizerService) Libresource
536: .getService("LibresourceSynchronizer");
537: FileData file = synchronizerService
538: .getNetworkFromWorkspace(wsId);
539:
540: //
541: InputStream is = file.getInputStream();
542: OutputStream os = response.getOutputStream();
543: int length;
544: byte[] buffer = new byte[BUFFER_SIZE];
545:
546: while ((length = is.read(buffer)) != -1) {
547: os.write(buffer, 0, length);
548: }
549:
550: os.flush();
551: os.close();
552: is.close();
553: } catch (LibresourceSecurityException e) {
554: response.sendError(STATUS_CODE_AUTH_ERROR);
555: } catch (Exception e) {
556: e.printStackTrace();
557: response.sendError(STATUS_CODE_SERVER_ERROR);
558: }
559: }
560:
561: public void getNetworkFromQueue(HttpServletRequest request,
562: HttpServletResponse response) throws ServletException,
563: IOException {
564: showHeaderParam("getNetFromQueue",
565: new String[] { SO6_QUEUE_ID }, request);
566:
567: try {
568: String queueId = request.getHeader(SO6_QUEUE_ID);
569: LibresourceSynchronizerService synchronizerService = (LibresourceSynchronizerService) Libresource
570: .getService("LibresourceSynchronizer");
571: FileData file = synchronizerService
572: .getNetworkFromQueue(new URI(queueId));
573:
574: //
575: InputStream is = file.getInputStream();
576: OutputStream os = response.getOutputStream();
577: int length;
578: byte[] buffer = new byte[BUFFER_SIZE];
579:
580: while ((length = is.read(buffer)) != -1) {
581: os.write(buffer, 0, length);
582: }
583:
584: os.flush();
585: os.close();
586: is.close();
587: } catch (LibresourceSecurityException e) {
588: response.sendError(STATUS_CODE_AUTH_ERROR);
589: } catch (Exception e) {
590: e.printStackTrace();
591: response.sendError(STATUS_CODE_SERVER_ERROR);
592: }
593: }
594:
595: // Workspace listener
596: public void notifyQueue(HttpServletRequest request,
597: HttpServletResponse response) throws ServletException,
598: IOException {
599: showHeaderParam("notifyQueue",
600: new String[] { SO6_REPLICA_URI }, request);
601:
602: try {
603: String replicaURI = request.getHeader(SO6_REPLICA_URI);
604: long lastTicket = Long.parseLong(request
605: .getHeader(SO6_REPLICA_TICKET));
606:
607: // System.out.println("notifyQueue " + replicaURI + " / " +
608: // lastTicket);
609: LibresourceSynchronizerService synchronizerService = (LibresourceSynchronizerService) Libresource
610: .getService("LibresourceSynchronizer");
611: synchronizerService.updateWorkspaceConnectionTicket(
612: new URI(replicaURI), lastTicket);
613: } catch (LibresourceSecurityException e) {
614: response.sendError(STATUS_CODE_AUTH_ERROR);
615: } catch (Exception e) {
616: e.printStackTrace();
617: response.sendError(STATUS_CODE_SERVER_ERROR);
618: }
619: }
620:
621: // ClientI
622: public void getLastTicket(HttpServletRequest request,
623: HttpServletResponse response) throws ServletException,
624: IOException {
625: showHeaderParam("getLastTicket",
626: new String[] { SO6_SYNCHRONIZER_URI }, request);
627:
628: try {
629: String synchronizerURI = request
630: .getHeader(SO6_SYNCHRONIZER_URI);
631: LibresourceSynchronizerService synchronizerService = (LibresourceSynchronizerService) Libresource
632: .getService("LibresourceSynchronizer");
633: long lastTicket = synchronizerService.getSynchronizer(
634: new URI(synchronizerURI)).getLastTicket();
635: response.setHeader("lastTicket", "" + lastTicket);
636: } catch (LibresourceSecurityException e) {
637: response.sendError(STATUS_CODE_AUTH_ERROR);
638: } catch (Exception e) {
639: e.printStackTrace();
640: response.sendError(STATUS_CODE_SERVER_ERROR);
641: }
642: }
643:
644: // For debuging
645: private void showHeaderParam(String methodeName, String[] keys,
646: HttpServletRequest request) {
647: if (System.getProperty("so6.debug") == null) {
648: return;
649: }
650:
651: System.out.println(methodeName);
652:
653: for (int i = 0; i < keys.length; i++) {
654: System.out.println(" - " + keys[i] + " = "
655: + request.getHeader(keys[i]));
656: }
657: }
658: }
|