qadevOOo/runner/helper/OfficeProvider.java

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: OfficeProvider.java,v $
  10  * $Revision: 1.22.2.5 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30 package helper;
  31
  32 //import com.sun.star.bridge.UnoUrlResolver;
  33 import com.sun.star.beans.XFastPropertySet;
  34 import com.sun.star.bridge.XUnoUrlResolver;
  35 import com.sun.star.container.XEnumeration;
  36 import com.sun.star.container.XEnumerationAccess;
  37 import com.sun.star.frame.XDesktop;
  38 import com.sun.star.lang.XMultiComponentFactory;
  39 import com.sun.star.lang.XMultiServiceFactory;
  40 import com.sun.star.uno.UnoRuntime;
  41 import com.sun.star.uno.XComponentContext;
  42 import com.sun.star.util.XCloseable;
  43 import com.sun.star.util.XStringSubstitution;
  44
  45 import java.io.File;
  46 import java.io.PrintWriter;
  47 import java.util.StringTokenizer;
  48
  49 import lib.TestParameters;
  50
  51 import share.DescEntry;
  52 import share.LogWriter;
  53
  54 import util.DynamicClassLoader;
  55 import util.PropertyName;
  56 import util.utils;
  57
  58 /**
  59  * This class will connect the office and start it if possible
  60  *
  61  */
  62 public class OfficeProvider implements AppProvider
  63 {
  64
  65     protected static boolean debug = false;
  66
  67     /**
  68      * copy the user layer to a safe place, usualy to $TMP/user_backup$USER
  69      * @param param
  70      * @param msf
  71      */
  72     public void backupUserLayer(TestParameters param, XMultiServiceFactory msf)
  73     {
  74         try
  75         {
  76             final XStringSubstitution sts = createStringSubstitution(msf);
  77             debug = param.getBool(PropertyName.DEBUG_IS_ACTIVE);
  78
  79             String userLayer = sts.getSubstituteVariableValue("$(user)");
  80             userLayer = getDirSys(userLayer);
  81             param.put("userLayer", userLayer);
  82
  83             final String copyLayer = util.utils.getUsersTempDir() + System.getProperty("file.separator") +
  84                     "user_backup" +
  85                     System.getProperty("user.name");
  86             param.put("copyLayer", copyLayer);
  87
  88
  89             dbg(" copy '" + userLayer + "' ->" + copyLayer + "'");
  90             // Slow machines the copy job could spend some time. To avoid activating of OfficeWatcher it must be pinged
  91             OfficeWatcherPing owp = new OfficeWatcherPing((OfficeWatcher) param.get(PropertyName.OFFICE_WATCHER));
  92             owp.start();
  93
  94             deleteFilesAndDirector (new File(copyLayer));
  95             FileTools.copyDirectory(new File(userLayer), new File(copyLayer), new String[]
  96                     {
  97                         "temp"
  98                     });
  99
 100             owp.finish();
 101
 102         }
 103         catch (com.sun.star.container.NoSuchElementException e)
 104         {
 105             System.out.println("User Variable '$(user)' not defined.");
 106         }
 107         catch (java.io.IOException e)
 108         {
 109             System.out.println("Couldn't backup user layer");
 110             e.printStackTrace();
 111         }
 112     }
 113
 114     /**
 115      * Dispose the office.
 116      * This method can only be used, if the office was connected in the first
 117      * place: getManager() was called first.
 118      * @param param
 119      * @return return true if desktop is terminates, else false
 120      */
 121     public boolean disposeManager(lib.TestParameters param)
 122     {
 123
 124         XMultiServiceFactory msf = (XMultiServiceFactory) param.getMSF();
 125
 126         if (msf == null)
 127         {
 128             return true;
 129         }
 130         else
 131         {
 132             XDesktop desk = null;
 133
 134             try
 135             {
 136                 desk = (XDesktop) UnoRuntime.queryInterface(XDesktop.class,
 137                         msf.createInstance(
 138                         "com.sun.star.frame.Desktop"));
 139             }
 140             catch (com.sun.star.uno.Exception ue)
 141             {
 142                 return false;
 143             }
 144
 145             msf = null;
 146
 147             if (desk != null)
 148             {
 149                 desk.terminate();
 150
 151                 return true;
 152             }
 153             else
 154             {
 155                 return false;
 156             }
 157         }
 158     }
 159
 160     /**
 161      * Method to get the ServiceManager of an Office
 162      * @param param
 163      * @return
 164      */
 165     public Object getManager(lib.TestParameters param)
 166     {
 167         String errorMessage = null;
 168         boolean bAppExecutionHasWarning = false;
 169         debug = param.getBool(PropertyName.DEBUG_IS_ACTIVE);
 170
 171         String additionalArgs = (String) param.get(
 172                 "AdditionalConnectionArguments");
 173
 174         if (additionalArgs == null)
 175         {
 176             additionalArgs = ";";
 177         }
 178         else
 179         {
 180             additionalArgs = "," + additionalArgs + ";";
 181         }
 182
 183         final String cncstr = "uno:" + param.get("ConnectionString") + ";urp" +
 184                 additionalArgs + "StarOffice.ServiceManager";
 185
 186         System.out.println("Connecting the Office with " + cncstr);
 187
 188         XMultiServiceFactory msf = connectOffice(cncstr);
 189
 190         // if the office is running and the office crashes while testing it could
 191         // be usesfull to restart the office if possible and continuing the tests.
 192         // Example: The UNO-API-Tests in the projects will be executed by calling
 193         // 'damke'. This connects to an existing office. If the office crashes
 194         // it is usefull to restart the office and continuing the tests.
 195         if ((param.getBool(util.PropertyName.AUTO_RESTART)) && (msf != null))
 196         {
 197             makeAppExecCommand(msf, param);
 198         }
 199
 200         if (msf == null)
 201         {
 202             String exc = "";
 203             Exception exConnectFailed = null;
 204             boolean isExecutable = false;
 205             boolean isAppKnown = ((cncstr.indexOf("host=localhost") > 0) || (cncstr.indexOf("pipe,name=") > 0));
 206             isAppKnown &= !((String) param.get("AppExecutionCommand")).equals("");
 207
 208             if (isAppKnown)
 209             {
 210                 dbg("Local Connection trying to start the Office");
 211
 212                 //ensure that a pending officewatcher gets finished before a new
 213                 //office is started
 214                 final OfficeWatcher ow_old = (OfficeWatcher) param.get("Watcher");
 215
 216                 if (ow_old != null)
 217                 {
 218                     ow_old.finish = true;
 219                 }
 220
 221                 final String cmd = (String) param.get("AppExecutionCommand");
 222                 dbg("AppExecutionCommand: " + cmd);
 223                 // validate the AppExecutionCommand, but try it out anyway.
 224                 // keep the error message for later.
 225                 errorMessage =
 226                         util.utils.validateAppExecutionCommand(cmd, (String) param.get("OperatingSystem"));
 227                 if (errorMessage.startsWith("Error"))
 228                 {
 229                     System.out.println(errorMessage);
 230                     return null;
 231                 }
 232                 bAppExecutionHasWarning = !errorMessage.equals("OK");
 233
 234                 final DynamicClassLoader dcl = new DynamicClassLoader();
 235                 final LogWriter log = (LogWriter) dcl.getInstance(
 236                         (String) param.get("LogWriter"));
 237
 238                 //create empty entry
 239                 final DescEntry Entry = new DescEntry();
 240                 Entry.entryName = "office";
 241                 Entry.longName = "office";
 242                 Entry.EntryType = "placebo";
 243                 Entry.isOptional = false;
 244                 Entry.isToTest = false;
 245                 Entry.SubEntryCount = 0;
 246                 Entry.hasErrorMsg = false;
 247                 Entry.State = "non possible";
 248                 Entry.UserDefinedParams = param;
 249
 250                 log.initialize(Entry, debug);
 251
 252                 final ProcessHandler ph = new ProcessHandler(cmd, (PrintWriter) log);
 253                 isExecutable = ph.executeAsynchronously();
 254
 255                 if (isExecutable)
 256                 {
 257                     param.put("AppProvider", ph);
 258                     final OfficeWatcher ow = new OfficeWatcher(param);
 259                     param.put("Watcher", ow);
 260                     ow.start();
 261                     ow.ping();
 262                 }
 263
 264                 int k = 0;
 265
 266                 // wait up to 21 seconds to get an office connection
 267                 while ((k < 42) && (msf == null))
 268                 {
 269                     try
 270                     {
 271                         msf = connect(cncstr);
 272                     }
 273                     catch (com.sun.star.uno.Exception ue)
 274                     {
 275                         exConnectFailed = ue;
 276                         exc = ue.getMessage();
 277                     }
 278                     catch (java.lang.Exception je)
 279                     {
 280                         exConnectFailed = je;
 281                         exc = je.getMessage();
 282                     }
 283                     if (msf == null)
 284                     {
 285                         try
 286                         {
 287                             Thread.sleep(k * 500);
 288                         }
 289                         catch (InterruptedException ex)
 290                         {
 291                         }
 292                     }
 293                     k++;
 294                 }
 295
 296                 if (msf == null)
 297                 {
 298                     System.out.println("Exception while connecting.\n" + exConnectFailed);
 299                     if (exc != null)
 300                     {
 301                         System.out.println(exc);
 302                     }
 303                     if (bAppExecutionHasWarning)
 304                     {
 305                         System.out.println(errorMessage);
 306                     }
 307                 }
 308                 else if (isExecutable)
 309                 {
 310                     if (!param.getBool(util.PropertyName.DONT_BACKUP_USERLAYER))
 311                     {
 312                         backupUserLayer(param, msf);
 313                     }
 314                 }
 315             }
 316             else
 317             {
 318                 System.out.println("Could not connect an Office and cannot start one.\n".concat("please start an office with following parameter:\n").
 319                         concat("\nsoffice -accept=").concat((String) param.get("ConnectionString")).concat(";urp;\n"));
 320                 if (bAppExecutionHasWarning)
 321                 {
 322                     System.out.println(errorMessage);
 323                 }
 324             }
 325         }
 326
 327         return msf;
 328     }
 329
 330     /**
 331      * Connect an Office
 332      * @param connectStr
 333      * @return
 334      * @throws com.sun.star.uno.Exception
 335      * @throws com.sun.star.uno.RuntimeException
 336      * @throws com.sun.star.connection.NoConnectException
 337      * @throws Exception
 338      */
 339     protected static XMultiServiceFactory connect(String connectStr)
 340             throws com.sun.star.uno.Exception,
 341             com.sun.star.uno.RuntimeException,
 342             com.sun.star.connection.NoConnectException,
 343             Exception
 344     {
 345
 346         // Get component context
 347         final XComponentContext xcomponentcontext = com.sun.star.comp.helper.Bootstrap.createInitialComponentContext(
 348                 null);
 349
 350         // initial serviceManager
 351         final XMultiComponentFactory xLocalServiceManager = xcomponentcontext.getServiceManager();
 352
 353         // create a connector, so that it can contact the office
 354 //        XUnoUrlResolver urlResolver = UnoUrlResolver.create(xcomponentcontext);
 355         final Object xUrlResolver = xLocalServiceManager.createInstanceWithContext(
 356                 "com.sun.star.bridge.UnoUrlResolver", xcomponentcontext);
 357         final XUnoUrlResolver urlResolver = (XUnoUrlResolver) UnoRuntime.queryInterface(
 358                 XUnoUrlResolver.class, xUrlResolver);
 359
 360         final Object rInitialObject = urlResolver.resolve(connectStr);
 361
 362         XMultiServiceFactory xMSF = null;
 363
 364         if (rInitialObject != null)
 365         {
 366             debug = true;
 367             dbg("resolved url");
 368
 369             xMSF = (XMultiServiceFactory) UnoRuntime.queryInterface(
 370                     XMultiServiceFactory.class, rInitialObject);
 371         }
 372
 373         return xMSF;
 374     }
 375
 376     /**
 377      * Close an office.
 378      * @param param The test parameters.
 379      * @param closeIfPossible If true, close even if
 380      * it was running before the test
 381      */
 382     public boolean closeExistingOffice(lib.TestParameters param, boolean closeIfPossible)
 383     {
 384
 385         XMultiServiceFactory msf = (XMultiServiceFactory) param.getMSF();
 386         final boolean alreadyConnected = (msf != null);
 387         debug = param.getBool(PropertyName.DEBUG_IS_ACTIVE);
 388
 389         if (alreadyConnected)
 390         {
 391             dbg("try to get ProcessHandler");
 392
 393             final ProcessHandler ph = (ProcessHandler) param.get("AppProvider");
 394
 395             if (ph != null)
 396             {
 397                 dbg("ProcessHandler != null");
 398
 399                 disposeOffice(msf, param);
 400
 401                 // dispose watcher in case it's still running.
 402                 dbg("try to get OfficeWatcher");
 403
 404                 final OfficeWatcher ow = (OfficeWatcher) param.get("Watcher");
 405
 406                 if ((ow != null) && ow.isAlive())
 407                 {
 408                     dbg("OfficeWatcher will be finished");
 409                     ow.finish = true;
 410                 }
 411                 else
 412                 {
 413                     dbg("OfficeWatcher seems to be finished");
 414                 }
 415
 416                 return true;
 417             }
 418             else
 419             {
 420                 if (closeIfPossible)
 421                 {
 422                     return disposeOffice(msf, param);
 423                 }
 424             }
 425         }
 426         else
 427         {
 428             final String cncstr = "uno:" + param.get("ConnectionString") +
 429                     ";urp;StarOffice.ServiceManager";
 430             dbg("try to connect office");
 431             msf = connectOffice(cncstr);
 432
 433             if (closeIfPossible)
 434             {
 435                 return disposeOffice(msf, param);
 436             }
 437         }
 438         dbg("closeExistingOffice finished");
 439         return true;
 440     }
 441
 442     private XMultiServiceFactory connectOffice(String cncstr)
 443     {
 444         XMultiServiceFactory msf = null;
 445         String exc = "";
 446         debug = true;
 447
 448         dbg("trying to connect to " + cncstr);
 449
 450         try
 451         {
 452             msf = connect(cncstr);
 453         }
 454         catch (com.sun.star.uno.Exception ue)
 455         {
 456             exc = ue.getMessage();
 457         }
 458         catch (java.lang.Exception je)
 459         {
 460             exc = je.getMessage();
 461         }
 462
 463         if (debug && exc != null && exc.length() != 0)
 464         {
 465             if (exc == null)
 466             {
 467                 exc = "";
 468             }
 469             dbg("Could not connect an Office. " + exc);
 470         }
 471
 472         return msf;
 473     }
 474
 475     private synchronized boolean disposeOffice(XMultiServiceFactory msf,
 476             TestParameters param)
 477     {
 478         XDesktop desk = null;
 479
 480         debug = param.getBool(PropertyName.DEBUG_IS_ACTIVE);
 481
 482         boolean result = true;
 483
 484         if (msf != null)
 485         {
 486
 487             // disable QuickStarter
 488             try
 489             {
 490                 Object quickStarter = msf.createInstance("com.sun.star.office.Quickstart");
 491                 XFastPropertySet fps = (XFastPropertySet) UnoRuntime.queryInterface(XFastPropertySet.class, quickStarter);
 492                 fps.setFastPropertyValue(0, false);
 493             }
 494             catch (com.sun.star.uno.Exception ex)
 495             {
 496                 dbg("ERROR: Could not disable QuickStarter: " + ex.toString());
 497             }
 498
 499             try
 500             {
 501                 desk = (XDesktop) UnoRuntime.queryInterface(XDesktop.class,
 502                         msf.createInstance(
 503                         "com.sun.star.frame.Desktop"));
 504                 msf = null;
 505
 506                 if (desk != null)
 507                 {
 508                     final boolean allClosed = closeAllWindows(desk);
 509
 510                     if (!allClosed)
 511                     {
 512                         dbg("Couldn't close all office windows!");
 513                     }
 514
 515                     dbg("Trying to terminate the desktop");
 516
 517                     desk.terminate();
 518                     dbg("Desktop terminated");
 519
 520                     try
 521                     {
 522                         final int closeTime = param.getInt(util.PropertyName.OFFICE_CLOSE_TIME_OUT);
 523                         dbg("the Office has " + closeTime / 1000 + " seconds for closing...");
 524                         Thread.sleep(closeTime);
 525                     }
 526                     catch (java.lang.InterruptedException e)
 527                     {
 528                     }
 529                 }
 530             }
 531             catch (com.sun.star.uno.Exception ue)
 532             {
 533                 result = false;
 534             }
 535             catch (com.sun.star.lang.DisposedException ue)
 536             {
 537                 result = false;
 538             }
 539         }
 540
 541         final String AppKillCommand = (String) param.get(util.PropertyName.APP_KILL_COMMAND);
 542         if (AppKillCommand != null)
 543         {
 544             String sAppKillCommand = StringHelper.removeSurroundQuoteIfExists(AppKillCommand);
 545             final StringTokenizer aKillCommandToken = new StringTokenizer(sAppKillCommand, ";");
 546             while (aKillCommandToken.hasMoreTokens())
 547             {
 548                 final String sKillCommand = aKillCommandToken.nextToken();
 549                 dbg("User defined an application to destroy the started process. Trying to execute: " + sKillCommand);
 550
 551                 final ProcessHandler pHdl = new ProcessHandler(sKillCommand, 1000); // 3000 seems to be too long
 552                 pHdl.runCommand();
 553
 554                 pHdl.kill();
 555             }
 556         }
 557
 558         final ProcessHandler ph = (ProcessHandler) param.get("AppProvider");
 559
 560         if (ph != null)
 561         {
 562             // dispose watcher in case it's still running.
 563             final OfficeWatcher ow = (OfficeWatcher) param.get("Watcher");
 564
 565             if ((ow != null) && ow.isAlive())
 566             {
 567                 ow.finish = true;
 568             }
 569
 570             ph.kill();
 571         }
 572
 573         param.remove("AppProvider");
 574         param.remove("ServiceFactory");
 575
 576         if (!param.getBool(util.PropertyName.DONT_BACKUP_USERLAYER))
 577         {
 578             //copy user_backup into user layer
 579             try
 580             {
 581                 final String userLayer = (String) param.get("userLayer");
 582                 final String copyLayer = (String) param.get("copyLayer");
 583                 if (userLayer != null && copyLayer != null)
 584                 {
 585                     deleteFilesAndDirector(new File(userLayer));
 586                     final File copyFile = new File(copyLayer);
 587                     dbg("copy '" + copyFile + "' -> '" + userLayer + "'");
 588                     FileTools.copyDirectory(copyFile, new File(userLayer), new String[]
 589                             {
 590                                 "temp"
 591                             });
 592                     dbg("copy '" + copyFile + "' -> '" + userLayer + "' finished");
 593
 594                 // remove all user_backup folder in temp dir
 595                 // this is for the case the runner was killed and some old backup folder still stay in temp dir
 596
 597
 598                 }
 599                 else
 600                 {
 601                     System.out.println("Cannot copy layer: '" + copyLayer + "' back to user layer: '" + userLayer + "'");
 602                 }
 603             }
 604             catch (java.io.IOException e)
 605             {
 606                 dbg("Couldn't recover from backup\n" + e.getMessage());
 607             }
 608         }
 609         return result;
 610     }
 611
 612     protected boolean closeAllWindows(XDesktop desk)
 613     {
 614         final XEnumerationAccess compEnumAccess = desk.getComponents();
 615         final XEnumeration compEnum = compEnumAccess.createEnumeration();
 616         boolean res = true;
 617
 618         try
 619         {
 620             while (compEnum.hasMoreElements())
 621             {
 622                 final XCloseable closer = (XCloseable) UnoRuntime.queryInterface(
 623                         XCloseable.class,
 624                         compEnum.nextElement());
 625
 626                 if (closer != null)
 627                 {
 628                     closer.close(true);
 629                 }
 630             }
 631         }
 632         catch (com.sun.star.util.CloseVetoException cve)
 633         {
 634             res = false;
 635         }
 636         catch (com.sun.star.container.NoSuchElementException nsee)
 637         {
 638             res = false;
 639         }
 640         catch (com.sun.star.lang.WrappedTargetException wte)
 641         {
 642             res = false;
 643         }
 644
 645         return res;
 646     }
 647
 648     public static XStringSubstitution createStringSubstitution(XMultiServiceFactory xMSF)
 649     {
 650         Object xPathSubst = null;
 651
 652         try
 653         {
 654             xPathSubst = xMSF.createInstance(
 655                     "com.sun.star.util.PathSubstitution");
 656         }
 657         catch (com.sun.star.uno.Exception e)
 658         {
 659             e.printStackTrace();
 660         }
 661
 662         if (xPathSubst != null)
 663         {
 664             return (XStringSubstitution) UnoRuntime.queryInterface(
 665                     XStringSubstitution.class, xPathSubst);
 666         }
 667         else
 668         {
 669             return null;
 670         }
 671     }
 672
 673     /**
 674      * converts directory without 'file:///' prefix.
 675      * and System dependend file separator
 676      * @param dir
 677      * @return
 678      */
 679     public static String getDirSys(String dir)
 680     {
 681         String sysDir = "";
 682
 683         final int idx = dir.indexOf("file://");
 684
 685         final int idx2 = dir.indexOf("file:///");
 686
 687         // remove leading 'file://'
 688         if (idx < 0)
 689         {
 690             sysDir = dir;
 691         }
 692         else
 693         {
 694             sysDir = dir.substring("file://".length());
 695         }
 696
 697         sysDir = utils.replaceAll13(sysDir, "%20", " ");
 698
 699         // append '/' if not there (e.g. linux)
 700         if (sysDir.charAt(sysDir.length() - 1) != '/')
 701         {
 702             sysDir += "/";
 703         }
 704
 705         // remove leading '/' and replace others with '\' on windows machines
 706         final String sep = System.getProperty("file.separator");
 707
 708         if (sep.equalsIgnoreCase("\\"))
 709         {
 710             if (!(idx2 < 0))
 711             {
 712                 sysDir = sysDir.substring(1);
 713             }
 714             else
 715             {
 716                 //network path
 717                 sysDir = "//" + sysDir;
 718             }
 719             sysDir = sysDir.replace('/', '\\');
 720         }
 721
 722         return sysDir;
 723     }
 724
 725     /**
 726      * If the office is connected but the <CODE>AppExecutionCommand</CODE> is not set,
 727      * this function asks the office for its location and fill the
 728      * <CODE>AppExecutionCommand</CODE> with valid contet.
 729      * This function was only called if parameter <CODE>AutoRestart</CODE> is set.
 730      * @param msf the <CODE>MultiServiceFactory</CODE>
 731      * @param param the <CODE>TestParameters</CODE>
 732      */
 733     private static void makeAppExecCommand(XMultiServiceFactory msf, TestParameters param)
 734     {
 735         debug = param.getBool(PropertyName.DEBUG_IS_ACTIVE);
 736
 737         // get existing AppExecutionCommand if available, else empty string
 738         String command = (String) param.get(util.PropertyName.APP_EXECUTION_COMMAND);
 739
 740         String connectionString;
 741         if (param.getBool(util.PropertyName.USE_PIPE_CONNECTION) == true)
 742         {
 743             // This is the default behaviour
 744             connectionString = (String) param.get(util.PropertyName.PIPE_CONNECTION_STRING);
 745         }
 746         else
 747         {
 748             // is used if UsePipeConnection=false
 749             connectionString = (String) param.get(util.PropertyName.CONNECTION_STRING);
 750         }
 751
 752         String sysBinDir = "";
 753
 754         try
 755         {
 756             sysBinDir = utils.getSystemURL(utils.expandMacro(msf, "$SYSBINDIR"));
 757         }
 758         catch (java.lang.Exception e)
 759         {
 760             dbg("could not get system binary directory");
 761             return;
 762         }
 763
 764         // does the existing command show to the connected office?
 765         if (command.indexOf(sysBinDir) == -1)
 766         {
 767             command = sysBinDir + System.getProperty("file.separator") + "soffice" +
 768                     " -norestore -accept=" + connectionString + ";urp;";
 769         }
 770
 771         dbg("update AppExecutionCommand: " + command);
 772
 773         param.put(util.PropertyName.APP_EXECUTION_COMMAND, command);
 774     }
 775
 776     private static void dbg(String message)
 777     {
 778         if (debug)
 779         {
 780             System.out.println(utils.getDateTime() + "OfficeProvider: " + message);
 781         }
 782
 783     }
 784
 785     private class OfficeWatcherPing extends Thread
 786     {
 787
 788         private final OfficeWatcher ow;
 789         private boolean bStop = false;
 790
 791         public OfficeWatcherPing(OfficeWatcher ow)
 792         {
 793             this.ow = ow;
 794         }
 795
 796         public void run()
 797         {
 798             System.out.println(utils.getDateTime() + "OfficeProvider:Owp: start ");
 799
 800             while (!bStop)
 801             {
 802                 System.out.println(utils.getDateTime() + "OfficeProvider:Owp: ping ");
 803                 ow.ping();
 804                 try
 805                 {
 806                     System.out.println(utils.getDateTime() + "OfficeProvider:Owp: sleep ");
 807                     OfficeWatcherPing.sleep(1000); // 5000
 808                 }
 809                 catch (InterruptedException ex)
 810                 {
 811                     ex.printStackTrace();
 812                 }
 813             }
 814
 815         }
 816
 817         public void finish()
 818         {
 819             synchronized(this)
 820             {
 821                 bStop = true;
 822                 System.out.println(utils.getDateTime() + "OfficeProvider:Owp: stop ");
 823
 824                 notify();
 825             }
 826         }
 827     }
 828
 829 private void deleteFilesAndDirector(File file)
 830         {
 831             File f = file;
 832             if(f.isDirectory())
 833             {
 834                 File files[] = f.listFiles();
 835                 for(int i = 0; i < files.length; i++)
 836                 {
 837                     deleteFilesAndDirector(files[i]);
 838                 }
 839                 f.delete();
 840             }
 841             else if (f.isFile())
 842             {
 843                 f.delete();
 844             }
 845         }
 846 }