예제 #1
0
  public ExecResult executeCommand(Session session, String command, String workingDir)
      throws PortalServiceException {
    ChannelExec channel = null;
    if (workingDir != null) {
      command = "cd " + workingDir + "; " + command;
    }

    try {
      channel = (ChannelExec) session.openChannel("exec");
      channel.setCommand(command);
      channel.setInputStream(null);
      channel.setErrStream(null);

      channel.connect();

      try (InputStream out = channel.getInputStream();
          InputStream err = channel.getErrStream()) {
        String outStr = readStream(out, channel);
        String errStr = readStream(err, channel);
        return new ExecResult(outStr, errStr, channel.getExitStatus());
      } catch (IOException | InterruptedException e) {
        throw new PortalServiceException(e.getMessage(), e);
      }
    } catch (JSchException e) {
      throw new PortalServiceException(e.getMessage(), e);
    } finally {
      if (channel != null) {
        channel.disconnect();
      }
    }
  }
예제 #2
0
  @Override
  public void run() {
    try {
      oftp = OftpAutomaton.build(false, CapabilityInit.BOTH, CapabilityMode.BOTH, 999999, 999);
      this.subscribe(MonitorEvent.class, oftp);
      oftp.subscribe(MonitorEvent.class, this);

      Thread oftpThread = new Thread(oftp);
      oftpThread.start();

      System.out.println("Wait for connection");
      ServerSocket server = new ServerSocket(LISTEN_PORT);
      Socket socket = server.accept();
      server.close();

      MonitorEvent nConInd = new MonitorEvent(new NetworkConnectionIndicationArchetype());
      nConInd.putAttribute(AbstractSocketInitialisationArchetype.SOCKET, socket);

      publish(nConInd);

      oftpThread.join();
    } catch (IOException | InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }
예제 #3
0
 public WorkspaceFactoryHelper(boolean allowOverride, String... args) {
   Path root = null;
   Path workspaceFilePath = null;
   try {
     Scratch scratch = new Scratch("/");
     root = scratch.dir("/workspace");
     workspaceFilePath = scratch.file("/workspace/WORKSPACE", args);
   } catch (IOException e) {
     fail("Shouldn't happen: " + e.getMessage());
   }
   StoredEventHandler eventHandler = new StoredEventHandler();
   builder =
       Package.newExternalPackageBuilder(
           Package.Builder.DefaultHelper.INSTANCE, workspaceFilePath, "");
   this.factory =
       new WorkspaceFactory(
           builder,
           TestRuleClassProvider.getRuleClassProvider(),
           ImmutableList.<PackageFactory.EnvironmentExtension>of(),
           Mutability.create("test"),
           allowOverride,
           root,
           root);
   Exception exception = null;
   try {
     factory.parse(ParserInputSource.create(workspaceFilePath), eventHandler);
   } catch (BuildFileContainsErrorsException e) {
     exception = e;
   } catch (IOException | InterruptedException e) {
     fail("Shouldn't happen: " + e.getMessage());
   }
   this.events = eventHandler.getEvents();
   this.exception = exception;
 }
예제 #4
0
  private static int executeCmd(String command) throws IOException, InterruptedException {
    try {
      // Execute the call
      log.debug("executing: " + command);
      Process process = Runtime.getRuntime().exec(command);
      // TODO Switch to using CommandLineUtils class to execute calls and use the provided exit
      // codes

      // on windows don't read result, as nothing returns (blocking process)
      if (SystemUtils.IS_OS_LINUX) {
        log.debug("checking Output of command");
        try (BufferedReader in =
            new BufferedReader(new InputStreamReader(process.getInputStream()))) {
          String result = "";
          String line;
          while ((line = in.readLine()) != null) {
            result += line;
          }
          log.debug(result);
        }
      }

      log.debug("waiting for command to finish");
      process.waitFor();
      return CommandLineUtils.getExecPID(process);

    } catch (IOException | InterruptedException e) {
      log.error("Error executing: " + command + " " + e.toString());
      throw e;
    }
  }
예제 #5
0
  @Override
  public boolean perform() {
    Properties config = new Properties();
    try (FileInputStream configIS = new FileInputStream("fileserver.properties")) {
      config.load(configIS);
    } catch (IOException e) {
      LOG.severe("Cannot read configuration file, msg =" + e);
    }
    String cmd = config.getProperty("stopMule", "");
    if (!cmd.isEmpty()) {
      BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(outputStream));
      try {
        ProcessBuilder pb = new ProcessBuilder();
        pb.command(cmd);
        Process proc = pb.start();
        proc.waitFor();

        writer.append("HTTP/1.0 200 OK\r\n");
        writer.append("Content-Type: text/plain\r\n");
        writer.append("Date: " + new Date() + "\r\n" + "Server: DgbSoft File server 1.0\r\n\r\n");
        writer.append("OK\r\n");
        writer.flush();
      } catch (IOException | InterruptedException e) {
        LOG.severe("Cannot start amule, msg = " + e.getMessage());
      }
    } else {
      LOG.warning("No stop mule command");
    }
    return true;
  }
예제 #6
0
파일: Main.java 프로젝트: johdah/iOthello
 /** @param args Arguments from console */
 public static void main(String[] args) {
   Othello othello = new Othello();
   try {
     othello.startOthello();
   } catch (IOException | InterruptedException e) {
     e.printStackTrace();
   }
 }
 @Override
 public void run() {
   try {
     startTimer();
   } catch (IOException | InterruptedException e) {
     e.printStackTrace();
   }
 }
 @Override
 public void close() {
   try {
     stop();
   } catch (IOException | InterruptedException e) {
     e.printStackTrace();
   }
   updater.cancel();
 }
예제 #9
0
 protected static void cleanOutputs() {
   try {
     String cleanerScript = BASE_TESTING_DIR + "\\0000_clean_outputs.bat";
     Process process = Runtime.getRuntime().exec(cleanerScript);
     process.waitFor();
   } catch (IOException | InterruptedException e) {
     e.printStackTrace();
   }
 }
예제 #10
0
  public void importArchive(int day) {
    try {
      Calendar processStartedAt = Calendar.getInstance();
      Calendar startDate = Calendar.getInstance();
      startDate.add(Calendar.DAY_OF_YEAR, -day);
      Calendar endDate = Calendar.getInstance();
      // List<Crawler> crawlers = new ArrayList<>();

      ScraperConfiguration config =
          Crawler.getScraperConfig(context, null, Crawler.CrawlType.DATA_ARCHIVE);
      Map params = new HashMap();
      dateFormat = new SimpleDateFormat(DSE_DATA_ARCHIVE_DATE_FORMAT);
      params.put("startDate", dateFormat.format(startDate.getTime()));
      params.put("endDate", dateFormat.format(endDate.getTime()));
      Item item = new Item(ALL_INSTRUMENT);
      Crawler crawler = new Crawler(config, item, Crawler.CrawlType.DATA_ARCHIVE, params);
      crawler.start();
      // crawlers.add(crawler);

      int counter = 0;
      crawler.join();
      List<Item> items = (List<Item>) crawler.getParams().get("items");
      List<Item> dsexItems = importDSEXArchive(day);
      System.out.println("dsex items: " + dsexItems.size());
      items.addAll(dsexItems);
      // filterOutUnneccessaryCodes(items, watchMatrix);

      if (items.size() > 0) {
        dao.open();
        dao.importItems(items);
        dao.close();
        // System.out.println("[" + (++counter) + "]Import data archive finished for " +
        // items.get(0).getCode());
      }

      Calendar processEndedAt = Calendar.getInstance();
      long elapsedTime =
          (processEndedAt.getTimeInMillis() - processStartedAt.getTimeInMillis()) / 1000;
      System.out.println(
          "Time elapsed to sync "
              + day
              + " day archive for "
              + items.size()
              + " item: "
              + (elapsedTime / 60)
              + " minutes "
              + (elapsedTime % 60)
              + " seconds");
    } catch (IOException | InterruptedException | SQLException | ClassNotFoundException ex) {
      Logger.getLogger(ImportService.class.getName()).log(Level.SEVERE, null, ex);
      ex.printStackTrace();
    }
  }
예제 #11
0
  @Override
  protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if (resultCode == RESULT_OK) {
      String key = null;
      if (requestCode == 1) {
        File f = new File(Environment.getExternalStorageDirectory().toString());
        for (File temp : f.listFiles()) {
          if (temp.getName().equals("temp.jpg")) {
            f = temp;
            break;
          }
        }
        try {
          Bitmap bitmap;
          BitmapFactory.Options bitmapOptions = new BitmapFactory.Options();

          bitmap = BitmapFactory.decodeFile(f.getAbsolutePath(), bitmapOptions);

          viewImage.setImageBitmap(bitmap);

          key = ClientHelpers.recognizeLandscape(f.getAbsolutePath());

        } catch (Exception e) {
          e.printStackTrace();
        }
      } else if (requestCode == 2) {

        Uri selectedImage = data.getData();
        String[] filePath = {MediaStore.Images.Media.DATA};
        Cursor c = getContentResolver().query(selectedImage, filePath, null, null, null);
        c.moveToFirst();
        int columnIndex = c.getColumnIndex(filePath[0]);
        String picturePath = c.getString(columnIndex);
        c.close();
        Bitmap thumbnail = (BitmapFactory.decodeFile(picturePath));
        viewImage.setImageBitmap(thumbnail);

        try {
          key = ClientHelpers.recognizeLandscape(picturePath);
        } catch (IOException | InterruptedException | JSONException e) {
          e.printStackTrace();
        }
      }

      if (key != null) {
        int landscapeID = Integer.parseInt(key);
        Intent intent = new Intent(this, LandscapeDetailActivity.class);
        intent.putExtra("landscapeID", landscapeID);
        startActivity(intent);
      }
    }
  }
예제 #12
0
  @Override
  public int run(String[] args) {
    // set up basic job information
    Configuration conf = getConf();

    try {
      runJob(conf);
    } catch (IOException | InterruptedException | ClassNotFoundException ex) {
      throw new RuntimeException(ex.getMessage());
    }

    return 0;
  }
예제 #13
0
  @Override
  public void process(
      final OperationList ops, final ImageInfo imageInfo, final OutputStream outputStream)
      throws ProcessorException {
    if (!getAvailableOutputFormats().contains(ops.getOutputFormat())) {
      throw new UnsupportedOutputFormatException();
    }

    // will receive stderr output from kdu_expand
    final ByteArrayOutputStream errorBucket = new ByteArrayOutputStream();
    try {
      final ReductionFactor reductionFactor = new ReductionFactor();
      final ProcessBuilder pb = getProcessBuilder(ops, imageInfo.getSize(), reductionFactor);
      logger.info("Invoking {}", StringUtils.join(pb.command(), " "));
      final Process process = pb.start();

      try (final InputStream processInputStream = process.getInputStream();
          final InputStream processErrorStream = process.getErrorStream()) {
        executorService.submit(new StreamCopier(processErrorStream, errorBucket));

        final ImageReader reader =
            new ImageReader(new InputStreamStreamSource(processInputStream), Format.TIF);
        try {
          postProcessUsingJava2d(reader, ops, imageInfo, reductionFactor, outputStream);
          final int code = process.waitFor();
          if (code != 0) {
            logger.warn("kdu_expand returned with code {}", code);
            final String errorStr = errorBucket.toString();
            if (errorStr != null && errorStr.length() > 0) {
              throw new ProcessorException(errorStr);
            }
          }
        } finally {
          reader.dispose();
        }
      } finally {
        process.destroy();
      }
    } catch (EOFException e) {
      // This will generally not have a message.
      logger.error("process(): EOFException ({})", e.getMessage(), ops);
    } catch (IOException | InterruptedException e) {
      String msg = e.getMessage();
      final String errorStr = errorBucket.toString();
      if (errorStr != null && errorStr.length() > 0) {
        msg += " (command output: " + errorStr + ")";
      }
      throw new ProcessorException(msg, e);
    }
  }
  @Override
  public boolean dispatchKeyEvent(KeyEvent e) {
    int keyCode = e.getKeyCode();
    if (e.getID() == KEY_PRESSED) {
      try {
        handleKeyPressed(keyCode);
      } catch (IOException | InterruptedException e1) {
        e1.printStackTrace();
      }
    } else if (e.getID() == KEY_RELEASED) {
      handleKeyReleased(keyCode);
    }

    return true;
  }
예제 #15
0
  @Override
  public boolean push(AbstractBuild<?, ?> build, BuildListener listener, String branchName) {
    try {
      listener.getLogger().println(EvoSuiteRecorder.LOG_PREFIX + "Pushing new test cases");

      if (this.hgClient.run("push").pwd(build.getWorkspace()).join() != 0) {
        return false;
      }
    } catch (IOException | InterruptedException e) {
      e.printStackTrace();
      return false;
    }

    return true;
  }
예제 #16
0
  public void runMetis() throws IOException {
    String[] args = this.arg_list.toArray(new String[this.arg_list.size()]);

    ProcessBuilder pb = new ProcessBuilder(args);
    pb.directory(exec_dir);
    //		Process p = pb.start();
    //
    //		// Any error? Or, Any output?
    //		StreamCollector errorStreams = new StreamCollector(p.getErrorStream(), "ERROR");
    //		StreamCollector outputStreams = new StreamCollector(p.getInputStream(), "OUTPUT");
    //		// Start stream collectors
    //		outputStreams.start();
    //		errorStreams.start();

    try {
      final Process p = pb.start();

      new Thread(
              new Runnable() {
                public void run() {
                  Scanner stdin = new Scanner(p.getInputStream());
                  while (stdin.hasNextLine()) {
                    System.out.println(stdin.nextLine());
                  }

                  stdin.close();
                }
              })
          .start();

      // Any error? Or, Any output?
      // StreamCollector errorStreams = new StreamCollector(p.getErrorStream(), "ERROR");
      // StreamCollector outputStreams = new StreamCollector(p.getInputStream(), "OUTPUT");

      // Start stream collectors
      // outputStreams.start();
      // errorStreams.start();

      p.waitFor();

      // PrintWriter printer = new PrintWriter(outputStreams);

    } catch (IOException | InterruptedException e) {
      e.printStackTrace();
    }
  }
예제 #17
0
  /** Sends the command TrueCrypt.exe /q background /d to unmount all TrueCrypt volumes */
  public static void unmountAll() throws IOException, InterruptedException {
    String command = createUnmountAllCommand();
    log.debug("unmounting: " + command);

    Process p;
    try {
      p = Runtime.getRuntime().exec(command);
      p.waitFor();
    } catch (IOException | InterruptedException e) {
      log.error("Error executing: " + command + " " + e.toString());
      throw e;
    }

    for (String drive : getSupportedDriveLetters()) {
      cleanUpMountingPoint(drive);
    }
  }
예제 #18
0
 public void runFNSemanticParsing() {
   try {
     Process proc =
         Runtime.getRuntime()
             .exec(
                 FrameNetOptions.ABS_PATH_DRIVER_SCRIPT
                     + " "
                     + FrameNetOptions.ABS_PATH_FNDATA
                     + FrameNetOptions.FN_FILE_NAME);
     BufferedReader br = new BufferedReader(new InputStreamReader(proc.getInputStream()));
     String line;
     while ((line = br.readLine()) != null) {
       System.out.println(line);
     }
     proc.waitFor();
   } catch (IOException | InterruptedException e) {
     e.printStackTrace();
   }
 }
예제 #19
0
  @Override
  public void executeSynchronously(
      RemoteWorkRequest request, StreamObserver<RemoteWorkResponse> responseObserver) {
    Path tempRoot = workPath.getRelative("build-" + UUID.randomUUID().toString());
    try {
      FileSystemUtils.createDirectoryAndParents(tempRoot);
      final ConcurrentMapActionCache actionCache = new ConcurrentMapActionCache(tempRoot, cache);
      final MemcacheWorkExecutor workExecutor =
          MemcacheWorkExecutor.createLocalWorkExecutor(actionCache, tempRoot);
      if (LOG_FINER) {
        LOG.fine(
            "Work received has "
                + request.getInputFilesCount()
                + " input files and "
                + request.getOutputFilesCount()
                + " output files.");
      }
      RemoteWorkResponse response = workExecutor.executeLocally(request);
      responseObserver.onNext(response);
      if (options.debug) {
        if (!response.getSuccess()) {
          LOG.warning("Work failed. Request: " + request.toString() + ".");

        } else if (LOG_FINER) {
          LOG.fine("Work completed.");
        }
      }
      if (!options.debug || response.getSuccess()) {
        FileSystemUtils.deleteTree(tempRoot);
      } else {
        LOG.warning("Preserving work directory " + tempRoot.toString() + ".");
      }
    } catch (IOException | InterruptedException e) {
      RemoteWorkResponse.Builder response = RemoteWorkResponse.newBuilder();
      response.setSuccess(false).setOut("").setErr("").setException(e.toString());
      responseObserver.onNext(response.build());
      if (e instanceof InterruptedException) {
        Thread.currentThread().interrupt();
      }
    } finally {
      responseObserver.onCompleted();
    }
  }
예제 #20
0
  @Override
  public void run() {
    getAndSendInitialInfo();
    System.out.println("CLIENT " + userid + ": registered on team " + team);

    while (true) {
      int plen = ClientState.getMaxSize();
      byte[] buf = cs.toBytes();
      DatagramPacket cp = new DatagramPacket(buf, plen);
      try {
        ds.send(cp);
        Thread.sleep(50);
      } catch (IOException | InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      }
    }
    // send client state
    // receive client data
  }
예제 #21
0
  public List<Item> importDSEXArchive(int day) {
    List<Item> items = new ArrayList<>();

    try {
      Calendar processStartedAt = Calendar.getInstance();
      Calendar startDate = Calendar.getInstance();
      startDate.add(Calendar.DAY_OF_YEAR, -day);
      Calendar endDate = Calendar.getInstance();

      String path = Utils.getConfigFilesPath();
      ScraperConfiguration config =
          Crawler.getScraperConfig(null, path, Crawler.CrawlType.DSEX_DATA_ARCHIVE);
      Map params = new HashMap();
      dateFormat = new SimpleDateFormat(DSE_DATA_ARCHIVE_DATE_FORMAT);
      params.put("startDate", dateFormat.format(startDate.getTime()));
      params.put("endDate", dateFormat.format(endDate.getTime()));
      Item item = new Item();
      Crawler crawler = new Crawler(config, item, Crawler.CrawlType.DSEX_DATA_ARCHIVE, params);
      crawler.start();
      crawler.join();
      items = (List<Item>) crawler.getParams().get("items");
      Calendar processEndedAt = Calendar.getInstance();
      long elapsedTime =
          (processEndedAt.getTimeInMillis() - processStartedAt.getTimeInMillis()) / 1000;
      System.out.println(
          "Time elapsed to sync "
              + day
              + " day archive for "
              + items.size()
              + " item: "
              + (elapsedTime / 60)
              + " minutes "
              + (elapsedTime % 60)
              + " seconds");
    } catch (IOException | InterruptedException ex) {
      Logger.getLogger(ImportService.class.getName()).log(Level.SEVERE, null, ex);
      ex.printStackTrace();
    }

    return items;
  }
예제 #22
0
 public static void watchService() {
   try {
     WatchService watcher = FileSystems.getDefault().newWatchService();
     WatchKey watchKey =
         Paths.get("/Users/caocao024/Desktop")
             .register(watcher, StandardWatchEventKinds.ENTRY_MODIFY);
     while (true) {
       // watchKey = watcher.take();
       for (WatchEvent<?> event : watcher.poll(10, TimeUnit.MILLISECONDS).pollEvents()) {
         if (event.kind() == StandardWatchEventKinds.ENTRY_MODIFY) {
           System.out.println("====" + event.context() + " | " + event.count());
         }
       }
       watchKey.reset();
     }
   } catch (IOException | InterruptedException e) {
     e
         .printStackTrace(); // To change body of catch statement use File | Settings | File
                             // Templates.
   }
 }
예제 #23
0
  /** start daemon */
  private static void start(Context context, Class<?> daemonClazzName, int interval) {
    String cmd =
        context.getDir(BIN_DIR_NAME, Context.MODE_PRIVATE).getAbsolutePath()
            + File.separator
            + DAEMON_BIN_NAME;

    /* create the command string */
    StringBuilder cmdBuilder = new StringBuilder();
    cmdBuilder.append(cmd);
    cmdBuilder.append(" -p ");
    cmdBuilder.append(context.getPackageName());
    cmdBuilder.append(" -s ");
    cmdBuilder.append(daemonClazzName.getName());
    cmdBuilder.append(" -t ");
    cmdBuilder.append(interval);

    try {
      Runtime.getRuntime().exec(cmdBuilder.toString()).waitFor();
    } catch (IOException | InterruptedException e) {
      Log.e(TAG, "start daemon error: " + e.getMessage());
    }
  }
예제 #24
0
  public static void main(String[] args) {
    try (ServerSocket server = new ServerSocket(1234)) {
      // wait 15 seconds for a connection
      server.setSoTimeout(15000);
      System.out.println("Listening...");

      try (Socket client = server.accept()) {
        // listen for messages from client
        Thread listen = new Thread(new SocketListener(client, true));
        listen.start();

        System.out.println("Client connected from: " + client.getInetAddress());

        // wait for listener to terminate
        listen.join();
      } catch (IOException | InterruptedException e) {
        e.printStackTrace();
      }
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
예제 #25
0
 /** 监听目录 */
 @Test
 public void testWatchFile() {
   // 监听目录变化
   try {
     WatchService watcher = FileSystems.getDefault().newWatchService();
     Path dir = FileSystems.getDefault().getPath(ParentPath);
     WatchKey key = dir.register(watcher, StandardWatchEventKinds.ENTRY_MODIFY);
     boolean shutdown = false;
     while (!shutdown) {
       System.out.println(1);
       key = watcher.take();
       for (WatchEvent<?> event : key.pollEvents()) {
         if (event.kind() == StandardWatchEventKinds.ENTRY_MODIFY) {
           System.out.println("Home dir changed!");
         }
       }
       key.reset();
     }
   } catch (IOException | InterruptedException e) {
     System.out.println(e.getMessage());
   }
 }
예제 #26
0
 @Override
 public void run() {
   while (!SH.get(tcn).isInterrupted()) {
     try {
       String rtn = Tclient(tcn);
       if (rtn.equals("reload")) {
         TNH.get(tcn).loggedin = 0;
         SH.get(tcn).interrupt();
         TNH.get(tcn).killme();
       }
     } catch (SocketException e) {
       dw.append("Server " + tcn + " offline.");
       TNH.get(tcn).loggedin = 0;
       SH.get(tcn).interrupt();
     } catch (IOException | InterruptedException e) {
       e.printStackTrace();
       dw.append("Server" + tcn + ": Bad Server Address");
       SH.get(tcn).interrupt();
     }
   }
   SH.remove(tcn);
 }
예제 #27
0
  @Override
  public Boolean call() {
    Log.i(TAG, "Trying to extract logcat for minidump");
    try {
      // Step 1: Extract a single logcat file.
      File logcatFile = getElidedLogcat();

      // Step 2: Make copies of logcat file for each  minidump then invoke
      // MinidumpPreparationService on each file pair.
      int len = mMinidumpFilenames.length;
      CrashFileManager fileManager = new CrashFileManager(mContext.getCacheDir());
      for (int i = 0; i < len; i++) {
        // Output crash dump file path to logcat so non-browser crashes appear too.
        Log.i(TAG, "Output crash dump:");
        Log.i(TAG, fileManager.getCrashFile(mMinidumpFilenames[i]).getAbsolutePath());
        processMinidump(logcatFile, mMinidumpFilenames[i], fileManager, i == len - 1);
      }
      return true;
    } catch (IOException | InterruptedException e) {
      Log.w(TAG, e.toString());
      return false;
    }
  }
예제 #28
0
  /** @return */
  public boolean sendPing() {
    ip = conteudo.getServerIp();
    port = conteudo.getServerPort();

    boolean retv = false;
    try {
      System.out.println("Sending a Ping.");
      InputStream ins = Runtime.getRuntime().exec("ping -n 1 -w 2000 " + ip).getInputStream();
      Thread.sleep(3000);
      byte[] prsbuf = new byte[ins.available()];
      ins.read(prsbuf);
      String parsstr = new StringTokenizer(new String(prsbuf), "%").nextToken().trim();

      if (!parsstr.endsWith("100")) {
        retv = true;
      }
      // System.out.println(parsstr);
      this.changeInfo(parsstr);
    } catch (IOException | InterruptedException e) {
      System.out.println("IOException" + e.getMessage());
      retv = false;
    }
    return retv;
  }
  public void openUrlInNewTab(URL url) {
    String urlstr = url.toExternalForm();

    if (webTabs.get(urlstr) != null) {
      setSelectedTab(webTabs.get(urlstr));
    } else
      Platform.runLater(
          () -> {
            try {
              if (ScriptingEngine.getLoginID() != null) {
                ScriptingGistTab newTab = new ScriptingGistTab("Web", url.toExternalForm(), false);
                newTab.setOnCloseRequest(
                    event -> {
                      webTabs.remove(urlstr);
                    });
                webTabs.put(urlstr, newTab);
                addTab(newTab, true);
              }
            } catch (IOException | InterruptedException e) {
              // TODO Auto-generated catch block
              e.printStackTrace();
            }
          });
  }
  @Override
  public MaterialDialog onCreateDialog(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mType = getArguments().getInt("dialogType");
    Resources res = getResources();
    MaterialDialog.Builder builder = new MaterialDialog.Builder(getActivity());
    builder.cancelable(true).title(getTitle());

    boolean sqliteInstalled = false;
    try {
      sqliteInstalled = Runtime.getRuntime().exec("sqlite3 --version").waitFor() == 0;
    } catch (IOException | InterruptedException e) {
      e.printStackTrace();
    }

    switch (mType) {
      case DIALOG_CURSOR_SIZE_LIMIT_EXCEEDED:
      case DIALOG_LOAD_FAILED:
        // Collection failed to load; give user the option of either choosing from repair options,
        // or closing
        // the activity
        return builder
            .cancelable(false)
            .content(getMessage())
            .iconAttr(R.attr.dialogErrorIcon)
            .positiveText(res.getString(R.string.error_handling_options))
            .negativeText(res.getString(R.string.close))
            .callback(
                new MaterialDialog.ButtonCallback() {
                  @Override
                  public void onPositive(MaterialDialog dialog) {
                    ((DeckPicker) getActivity()).showDatabaseErrorDialog(DIALOG_ERROR_HANDLING);
                  }

                  @Override
                  public void onNegative(MaterialDialog dialog) {
                    ((DeckPicker) getActivity()).exit();
                  }
                })
            .show();

      case DIALOG_DB_ERROR:
        // Database Check failed to execute successfully; give user the option of either choosing
        // from repair
        // options, submitting an error report, or closing the activity
        MaterialDialog dialog =
            builder
                .cancelable(false)
                .content(getMessage())
                .iconAttr(R.attr.dialogErrorIcon)
                .positiveText(res.getString(R.string.error_handling_options))
                .negativeText(res.getString(R.string.answering_error_report))
                .neutralText(res.getString(R.string.close))
                .callback(
                    new MaterialDialog.ButtonCallback() {
                      @Override
                      public void onPositive(MaterialDialog dialog) {
                        ((DeckPicker) getActivity()).showDatabaseErrorDialog(DIALOG_ERROR_HANDLING);
                      }

                      @Override
                      public void onNegative(MaterialDialog dialog) {
                        ((DeckPicker) getActivity()).sendErrorReport();
                        dismissAllDialogFragments();
                      }

                      @Override
                      public void onNeutral(MaterialDialog dialog) {
                        ((DeckPicker) getActivity()).exit();
                      }
                    })
                .show();
        dialog
            .getCustomView()
            .findViewById(R.id.buttonDefaultNegative)
            .setEnabled(((DeckPicker) getActivity()).hasErrorFiles());
        return dialog;

      case DIALOG_ERROR_HANDLING:
        // The user has asked to see repair options; allow them to choose one of the repair options
        // or go back
        // to the previous dialog
        ArrayList<String> options = new ArrayList<>();
        ArrayList<Integer> values = new ArrayList<>();
        if (!((AnkiActivity) getActivity()).colIsOpen()) {
          // retry
          options.add(res.getString(R.string.backup_retry_opening));
          values.add(0);
        } else {
          // fix integrity
          options.add(res.getString(R.string.check_db));
          values.add(1);
        }
        // repair db with sqlite
        if (sqliteInstalled) {
          options.add(res.getString(R.string.backup_error_menu_repair));
          values.add(2);
        }
        // // restore from backup
        options.add(res.getString(R.string.backup_restore));
        values.add(3);
        // delete old collection and build new one
        options.add(res.getString(R.string.backup_full_sync_from_server));
        values.add(4);
        // delete old collection and build new one
        options.add(res.getString(R.string.backup_del_collection));
        values.add(5);

        String[] titles = new String[options.size()];
        mRepairValues = new int[options.size()];
        for (int i = 0; i < options.size(); i++) {
          titles[i] = options.get(i);
          mRepairValues[i] = values.get(i);
        }

        dialog =
            builder
                .iconAttr(R.attr.dialogErrorIcon)
                .negativeText(res.getString(R.string.dialog_cancel))
                .items(titles)
                .itemsCallback(
                    new MaterialDialog.ListCallback() {
                      @Override
                      public void onSelection(
                          MaterialDialog materialDialog,
                          View view,
                          int which,
                          CharSequence charSequence) {
                        switch (mRepairValues[which]) {
                          case 0:
                            ((DeckPicker) getActivity()).restartActivity();
                            return;
                          case 1:
                            ((DeckPicker) getActivity())
                                .showDatabaseErrorDialog(DIALOG_CONFIRM_DATABASE_CHECK);
                            return;
                          case 2:
                            ((DeckPicker) getActivity())
                                .showDatabaseErrorDialog(DIALOG_REPAIR_COLLECTION);
                            return;
                          case 3:
                            ((DeckPicker) getActivity())
                                .showDatabaseErrorDialog(DIALOG_RESTORE_BACKUP);
                            return;
                          case 4:
                            ((DeckPicker) getActivity())
                                .showDatabaseErrorDialog(DIALOG_FULL_SYNC_FROM_SERVER);
                            return;
                          case 5:
                            ((DeckPicker) getActivity())
                                .showDatabaseErrorDialog(DIALOG_NEW_COLLECTION);
                        }
                      }
                    })
                .show();
        return dialog;

      case DIALOG_REPAIR_COLLECTION:
        // Allow user to run BackupManager.repairCollection()
        return builder
            .content(getMessage())
            .iconAttr(R.attr.dialogErrorIcon)
            .positiveText(res.getString(R.string.dialog_positive_repair))
            .negativeText(res.getString(R.string.dialog_cancel))
            .callback(
                new MaterialDialog.ButtonCallback() {
                  @Override
                  public void onPositive(MaterialDialog dialog) {
                    ((DeckPicker) getActivity()).repairDeck();
                    dismissAllDialogFragments();
                  }
                })
            .show();

      case DIALOG_RESTORE_BACKUP:
        // Allow user to restore one of the backups
        String path = CollectionHelper.getInstance().getCollectionPath(getActivity());
        File[] files = BackupManager.getBackups(new File(path));
        mBackups = new File[files.length];
        for (int i = 0; i < files.length; i++) {
          mBackups[i] = files[files.length - 1 - i];
        }
        if (mBackups.length == 0) {
          builder
              .title(res.getString(R.string.backup_restore))
              .content(getMessage())
              .positiveText(res.getString(R.string.dialog_ok))
              .callback(
                  new MaterialDialog.ButtonCallback() {
                    @Override
                    public void onPositive(MaterialDialog dialog) {
                      ((DeckPicker) getActivity()).showDatabaseErrorDialog(DIALOG_ERROR_HANDLING);
                    }
                  });
        } else {
          String[] dates = new String[mBackups.length];
          for (int i = 0; i < mBackups.length; i++) {
            dates[i] =
                mBackups[i]
                    .getName()
                    .replaceAll(".*-(\\d{4}-\\d{2}-\\d{2})-(\\d{2})-(\\d{2}).apkg", "$1 ($2:$3 h)");
          }
          builder
              .title(res.getString(R.string.backup_restore_select_title))
              .negativeText(res.getString(R.string.dialog_cancel))
              .callback(
                  new MaterialDialog.ButtonCallback() {
                    @Override
                    public void onNegative(MaterialDialog dialog) {
                      dismissAllDialogFragments();
                    }
                  })
              .items(dates)
              .itemsCallbackSingleChoice(
                  dates.length,
                  new MaterialDialog.ListCallbackSingleChoice() {
                    @Override
                    public boolean onSelection(
                        MaterialDialog materialDialog,
                        View view,
                        int which,
                        CharSequence charSequence) {
                      if (mBackups[which].length() > 0) {
                        // restore the backup if it's valid
                        ((DeckPicker) getActivity()).restoreFromBackup(mBackups[which].getPath());
                        dismissAllDialogFragments();
                      } else {
                        // otherwise show an error dialog
                        new MaterialDialog.Builder(getActivity())
                            .title(R.string.backup_error)
                            .content(R.string.backup_invalid_file_error)
                            .positiveText(R.string.dialog_ok)
                            .build()
                            .show();
                      }
                      return true;
                    }
                  });
        }
        return builder.show();

      case DIALOG_NEW_COLLECTION:
        // Allow user to create a new empty collection
        return builder
            .content(getMessage())
            .positiveText(res.getString(R.string.dialog_positive_create))
            .negativeText(res.getString(R.string.dialog_cancel))
            .callback(
                new MaterialDialog.ButtonCallback() {
                  @Override
                  public void onPositive(MaterialDialog dialog) {
                    CollectionHelper.getInstance().closeCollection(false);
                    String path = CollectionHelper.getCollectionPath(getActivity());
                    if (BackupManager.moveDatabaseToBrokenFolder(path, false)) {
                      ((DeckPicker) getActivity()).restartActivity();
                    } else {
                      ((DeckPicker) getActivity()).showDatabaseErrorDialog(DIALOG_LOAD_FAILED);
                    }
                  }
                })
            .show();

      case DIALOG_CONFIRM_DATABASE_CHECK:
        // Confirmation dialog for database check
        return builder
            .content(getMessage())
            .positiveText(res.getString(R.string.dialog_ok))
            .negativeText(res.getString(R.string.dialog_cancel))
            .callback(
                new MaterialDialog.ButtonCallback() {
                  @Override
                  public void onPositive(MaterialDialog dialog) {
                    ((DeckPicker) getActivity()).integrityCheck();
                    dismissAllDialogFragments();
                  }
                })
            .show();

      case DIALOG_CONFIRM_RESTORE_BACKUP:
        // Confirmation dialog for backup restore
        return builder
            .content(getMessage())
            .positiveText(res.getString(R.string.dialog_continue))
            .negativeText(res.getString(R.string.dialog_cancel))
            .callback(
                new MaterialDialog.ButtonCallback() {
                  @Override
                  public void onPositive(MaterialDialog dialog) {
                    ((DeckPicker) getActivity()).showDatabaseErrorDialog(DIALOG_RESTORE_BACKUP);
                  }
                })
            .show();

      case DIALOG_FULL_SYNC_FROM_SERVER:
        // Allow user to do a full-sync from the server
        return builder
            .content(getMessage())
            .positiveText(res.getString(R.string.dialog_positive_overwrite))
            .negativeText(res.getString(R.string.dialog_cancel))
            .callback(
                new MaterialDialog.ButtonCallback() {
                  @Override
                  public void onPositive(MaterialDialog dialog) {
                    ((DeckPicker) getActivity()).sync("download");
                    dismissAllDialogFragments();
                  }
                })
            .show();

      default:
        return null;
    }
  }