synchronized void migrateData(DataStore targetStore) {
    ForceLoadAllClaims(this);
    targetStore.ClearInventoryOnJoinPlayers = ClearInventoryOnJoinPlayers;
    // migrate claims
    for (Claim c : this.claims) {
      GriefPrevention.AddLogEntry("Migrating Claim #" + c.getID());
      targetStore.addClaim(c);
    }

    // migrate groups
    Iterator<String> groupNamesEnumerator = this.permissionToBonusBlocksMap.keySet().iterator();
    while (groupNamesEnumerator.hasNext()) {
      String groupName = groupNamesEnumerator.next();
      targetStore.saveGroupBonusBlocks(groupName, this.permissionToBonusBlocksMap.get(groupName));
    }

    // migrate players
    for (PlayerData pdata : getAllPlayerData()) {

      targetStore.playerNameToPlayerDataMap.put(pdata.playerName, pdata);
      targetStore.savePlayerData(pdata.playerName, pdata);
    }

    // migrate next claim ID
    if (this.nextClaimID > targetStore.nextClaimID) {
      targetStore.setNextClaimID(this.nextClaimID);
    }

    // rename player and claim data folders so the migration won't run again
    int i = 0;
    File claimsBackupFolder;
    File playersBackupFolder;
    do {
      String claimsFolderBackupPath = claimDataFolderPath;
      if (i > 0) claimsFolderBackupPath += String.valueOf(i);
      claimsBackupFolder = new File(claimsFolderBackupPath);

      String playersFolderBackupPath = playerDataFolderPath;
      if (i > 0) playersFolderBackupPath += String.valueOf(i);
      playersBackupFolder = new File(playersFolderBackupPath);
      i++;
    } while (claimsBackupFolder.exists() || playersBackupFolder.exists());

    File claimsFolder = new File(claimDataFolderPath);
    File playersFolder = new File(playerDataFolderPath);

    claimsFolder.renameTo(claimsBackupFolder);
    playersFolder.renameTo(playersBackupFolder);

    GriefPrevention.AddLogEntry(
        "Backed your file system data up to "
            + claimsBackupFolder.getName()
            + " and "
            + playersBackupFolder.getName()
            + ".");
    GriefPrevention.AddLogEntry(
        "If your migration encountered any problems, you can restore those data with a quick copy/paste.");
    GriefPrevention.AddLogEntry(
        "When you're satisfied that all your data have been safely migrated, consider deleting those folders.");
  }
Exemple #2
0
  /** Save the contents of the FS image */
  void saveFSImage(File fullimage, File edits) throws IOException {
    File curFile = new File(fullimage, FS_IMAGE);
    File newFile = new File(fullimage, NEW_FS_IMAGE);
    File oldFile = new File(fullimage, OLD_FS_IMAGE);

    //
    // Write out data
    //
    DataOutputStream out =
        new DataOutputStream(new BufferedOutputStream(new FileOutputStream(newFile)));
    try {
      out.writeInt(rootDir.numItemsInTree() - 1);
      rootDir.saveImage("", out);
    } finally {
      out.close();
    }

    //
    // Atomic move sequence
    //
    // 1.  Move cur to old
    curFile.renameTo(oldFile);

    // 2.  Move new to cur
    newFile.renameTo(curFile);

    // 3.  Remove pending-edits file (it's been integrated with newFile)
    edits.delete();

    // 4.  Delete old
    oldFile.delete();
  }
    private File addBlock(Block b, File src, boolean createOk, boolean resetIdx)
        throws IOException {
      if (numBlocks < maxBlocksPerDir) {
        File dest = new File(dir, b.getBlockName());
        File metaData = getMetaFile(src, b);
        File newmeta = getMetaFile(dest, b);
        if (!metaData.renameTo(newmeta) || !src.renameTo(dest)) {
          throw new IOException(
              "could not move files for " + b + " from tmp to " + dest.getAbsolutePath());
        }
        if (DataNode.LOG.isDebugEnabled()) {
          DataNode.LOG.debug("addBlock: Moved " + metaData + " to " + newmeta);
          DataNode.LOG.debug("addBlock: Moved " + src + " to " + dest);
        }

        numBlocks += 1;
        return dest;
      }

      if (lastChildIdx < 0 && resetIdx) {
        // reset so that all children will be checked
        lastChildIdx = random.nextInt(children.length);
      }

      if (lastChildIdx >= 0 && children != null) {
        // Check if any child-tree has room for a block.
        for (int i = 0; i < children.length; i++) {
          int idx = (lastChildIdx + i) % children.length;
          File file = children[idx].addBlock(b, src, false, resetIdx);
          if (file != null) {
            lastChildIdx = idx;
            return file;
          }
        }
        lastChildIdx = -1;
      }

      if (!createOk) {
        return null;
      }

      if (children == null || children.length == 0) {
        children = new FSDir[maxBlocksPerDir];
        for (int idx = 0; idx < maxBlocksPerDir; idx++) {
          children[idx] = new FSDir(new File(dir, DataStorage.BLOCK_SUBDIR_PREFIX + idx));
        }
      }

      // now pick a child randomly for creating a new set of subdirs.
      lastChildIdx = random.nextInt(children.length);
      return children[lastChildIdx].addBlock(b, src, true, false);
    }
 public void saveCache(
     JMXInstrumentedCache<K, V> cache, File savedCachePath, Function<K, byte[]> converter)
     throws IOException {
   long start = System.currentTimeMillis();
   String msgSuffix = " " + savedCachePath.getName() + " for " + cfname + " of " + ksname;
   logger.debug("saving" + msgSuffix);
   int count = 0;
   File tmpFile =
       File.createTempFile(savedCachePath.getName(), null, savedCachePath.getParentFile());
   FileOutputStream fout = new FileOutputStream(tmpFile);
   ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(fout));
   FileDescriptor fd = fout.getFD();
   for (K key : cache.getKeySet()) {
     byte[] bytes = converter.apply(key);
     out.writeInt(bytes.length);
     out.write(bytes);
     ++count;
   }
   out.flush();
   fd.sync();
   out.close();
   if (!tmpFile.renameTo(savedCachePath))
     throw new IOException("Unable to rename cache to " + savedCachePath);
   if (logger.isDebugEnabled())
     logger.debug(
         "saved "
             + count
             + " keys in "
             + (System.currentTimeMillis() - start)
             + " ms from"
             + msgSuffix);
 }
Exemple #5
0
  /** Maintain the versions of the file we are about to for writing. */
  private static boolean shuffleVersions(String file) {
    File f = new File(file);

    if (!f.exists()) {
      return true;
    }
    int version = 99;

    boolean found = false;

    do {
      String fileVersion = file + String.format("_%02d", version);
      File vf = new File(fileVersion);

      if (vf.exists()) {
        found = true;
      } else {
        version--;
      }

    } while (!found && version >= 0);

    version++;

    String fileVersion = file + String.format("_%02d", version);

    File newf = new File(fileVersion);

    return f.renameTo(newf);
  }
  private void saveConfiguration(
      BundleInfo[] configuration, File outputFile, URI installArea, boolean backup)
      throws IOException {
    if (backup && outputFile.exists()) {
      File backupFile = Utils.getSimpleDataFormattedFile(outputFile);
      if (!outputFile.renameTo(backupFile)) {
        throw new IOException("Fail to rename from (" + outputFile + ") to (" + backupFile + ")");
      }
    }

    org.eclipse.equinox.internal.simpleconfigurator.utils.BundleInfo[] simpleInfos =
        convertBundleInfos(configuration, installArea);

    // if empty remove the configuration file
    if (simpleInfos == null || simpleInfos.length == 0) {
      if (outputFile.exists()) {
        outputFile.delete();
      }
      File parentDir = outputFile.getParentFile();
      if (parentDir.exists()) {
        parentDir.delete();
      }
      return;
    }
    SimpleConfiguratorManipulatorUtils.writeConfiguration(simpleInfos, outputFile);
    if (CONFIG_LIST.equals(outputFile.getName())
        && installArea != null
        && isSharedInstallSetup(URIUtil.toFile(installArea), outputFile))
      rememberSharedBundlesInfoTimestamp(installArea, outputFile.getParentFile());
  }
 @NotNull
 private String createLocalFile(@NotNull ObjectId id, @NotNull ObjectLoader loader)
     throws IOException {
   // Create LFS stream.
   final File tmpFile = new File(tempPath, UUID.randomUUID().toString());
   final MessageDigest md = createSha256();
   try (InputStream istream = loader.openStream();
       OutputStream ostream = new FileOutputStream(tmpFile)) {
     byte[] buffer = new byte[0x10000];
     while (true) {
       int size = istream.read(buffer);
       if (size <= 0) break;
       ostream.write(buffer, 0, size);
       md.update(buffer, 0, size);
     }
   }
   final String hash = new String(Hex.encodeHex(md.digest(), true));
   cacheSha256.putIfAbsent(id.name(), hash);
   cache.commit();
   // Rename file.
   final File lfsFile =
       new File(
           basePath,
           "lfs/objects/" + hash.substring(0, 2) + "/" + hash.substring(2, 4) + "/" + hash);
   makeParentDirs(lfsFile.getParentFile());
   if (lfsFile.exists()) {
     if (!tmpFile.delete()) {
       log.warn("Can't delete temporary file: {}", lfsFile.getAbsolutePath());
     }
   } else if (!tmpFile.renameTo(lfsFile)) {
     throw new IOException("Can't rename file: " + tmpFile + " -> " + lfsFile);
   }
   return hash;
 }
  private void copyAllFilesToLogDir(File node, File parent) throws IOException {
    if (!node.getAbsoluteFile().equals(parent.getAbsoluteFile())
        && node.isFile()
        && !node.getParentFile().equals(parent)) {
      String fileNamePrefix = node.getName().substring(0, node.getName().lastIndexOf('.'));
      String fileNameSuffix = node.getName().substring(node.getName().lastIndexOf('.'));
      String newFilePath =
          node.getParentFile().getAbsolutePath()
              + File.separator
              + fileNamePrefix.replace(".", "_")
              + fileNameSuffix;

      File newNode = new File(newFilePath);
      if (node.renameTo(newNode)) {
        FileUtils.copyFileToDirectory(newNode, parent);
      }
    }
    if (node.isDirectory()) {
      String[] subNote = node.list();
      for (String filename : subNote) {
        copyAllFilesToLogDir(new File(node, filename), parent);
      }
      if (!node.equals(parent)) {
        FileUtils.deleteDirectory(node);
      }
    }
  }
  public static void rename(@NotNull File source, @NotNull File target) throws IOException {
    if (source.renameTo(target)) return;
    if (!source.exists()) return;

    copy(source, target);
    delete(source);
  }
Exemple #10
0
 public void renameDataSourceDir(String oldDataSourceId, String newDataSourceId)
     throws FileNotFoundException, IOException {
   File dataSourceDir = getDataSourceDir(oldDataSourceId);
   if (dataSourceDir.exists()) {
     dataSourceDir.renameTo(getDataSourceDir(newDataSourceId));
   }
 }
  public static boolean moveDirWithContent(@NotNull File fromDir, @NotNull File toDir) {
    if (!toDir.exists()) return fromDir.renameTo(toDir);

    File[] files = fromDir.listFiles();
    if (files == null) return false;

    boolean success = true;

    for (File fromFile : files) {
      File toFile = new File(toDir, fromFile.getName());
      success = success && fromFile.renameTo(toFile);
    }
    fromDir.delete();

    return success;
  }
Exemple #12
0
  private static void preserveFiles(String filename) {
    File oldFile = new File(filename);
    File saveFile = new File(filename + ".temp");
    SimpleDateFormat sdf = new SimpleDateFormat("ddMMMyy_HHmm");
    String nowStr = sdf.format(new Date());
    String retainFilename = makeBackupFilename(filename, nowStr);
    File retainFile = new File(retainFilename);
    if (retainFile.exists()) retainFile.delete();

    String oldestSave = JConfig.queryConfiguration("save.file.4", "");
    if (oldestSave.length() != 0) {
      File oldest = new File(oldestSave);
      if (oldest.exists()) {
        backupByDate(filename, oldest);
      }
    }

    for (int i = 4; i > 0; i--) {
      JConfig.setConfiguration(
          "save.file." + i, JConfig.queryConfiguration("save.file." + (i - 1), ""));
    }

    File keepFile = new File(retainFilename);
    if (!oldFile.renameTo(keepFile)) {
      JConfig.log()
          .logDebug(
              "Renaming the old file ("
                  + oldFile
                  + ") to the retain file ("
                  + keepFile
                  + ") failed!");
    }
    JConfig.setConfiguration("save.file.0", retainFilename);

    File standard = new File(filename);
    if (!saveFile.renameTo(standard)) {
      JConfig.log()
          .logDebug(
              "Renaming the new file ("
                  + saveFile
                  + ") to the standard filename ("
                  + standard
                  + ") failed!");
    }
  }
 public static void main(final String[] args) {
   final File targetFile = new File("D:\\abc.def");
   final File tmp = new File(targetFile.getPath() + ".frftmp");
   if (!FileAccess.compressFileGZip(targetFile, tmp)) {
     return; // error
   }
   targetFile.delete();
   tmp.renameTo(targetFile);
 }
Exemple #14
0
  /**
   * Load in the filesystem image. It's a big list of filenames and blocks. Return whether we should
   * "re-save" and consolidate the edit-logs
   */
  boolean loadFSImage(File fsdir, File edits) throws IOException {
    //
    // Atomic move sequence, to recover from interrupted save
    //
    File curFile = new File(fsdir, FS_IMAGE);
    File newFile = new File(fsdir, NEW_FS_IMAGE);
    File oldFile = new File(fsdir, OLD_FS_IMAGE);

    // Maybe we were interrupted between 2 and 4
    if (oldFile.exists() && curFile.exists()) {
      oldFile.delete();
      if (edits.exists()) {
        edits.delete();
      }
    } else if (oldFile.exists() && newFile.exists()) {
      // Or maybe between 1 and 2
      newFile.renameTo(curFile);
      oldFile.delete();
    } else if (curFile.exists() && newFile.exists()) {
      // Or else before stage 1, in which case we lose the edits
      newFile.delete();
    }

    //
    // Load in bits
    //
    if (curFile.exists()) {
      DataInputStream in =
          new DataInputStream(new BufferedInputStream(new FileInputStream(curFile)));
      try {
        int numFiles = in.readInt();
        for (int i = 0; i < numFiles; i++) {
          UTF8 name = new UTF8();
          name.readFields(in);
          int numBlocks = in.readInt();
          if (numBlocks == 0) {
            unprotectedAddFile(name, null);
          } else {
            Block blocks[] = new Block[numBlocks];
            for (int j = 0; j < numBlocks; j++) {
              blocks[j] = new Block();
              blocks[j].readFields(in);
            }
            unprotectedAddFile(name, blocks);
          }
        }
      } finally {
        in.close();
      }
    }

    if (edits.exists() && loadFSEdits(edits) > 0) {
      return true;
    } else {
      return false;
    }
  }
Exemple #15
0
  /**
   * 코드저장소 프로젝트명을 변경하고 결과를 반환한다.
   *
   * @param projectName
   * @return 코드저장소 이름 변경성공시 true / 실패시 false
   */
  @Override
  public boolean renameTo(String projectName) {

    File src = new File(getRepoPrefix() + this.ownerName + "/" + this.projectName);
    File dest = new File(getRepoPrefix() + this.ownerName + "/" + projectName);
    src.setWritable(true);

    return src.renameTo(dest);
  }
Exemple #16
0
  public void setFileName(int row, String name) {
    // avoid moving a File by renaming it !!
    if (name.indexOf("..") < 0 && name.indexOf("/") < 0 && name.indexOf("\\") < 0) {
      File oldFile = getFile(filenames[row]);
      File newFile = new File(oldFile.getParent() + File.separator + name);

      filenames[row] = name;

      oldFile.renameTo(newFile);
    }
  }
  /**
   * Loop through the ZIP file, copying its entries into a new, temporary ZIP file, skipping the
   * entry to be deleted. Then replace the original file with the new one.
   */
  protected Integer deleteEntry() throws XMLDataStoreException {
    try {
      ZipInputStream inStream = this.buildZipInputStream();
      File outFile = this.buildTempFile();
      ZipOutputStream outStream = new ZipOutputStream(new FileOutputStream(outFile));

      byte[] buffer = new byte[32768];
      int inCount = 0;
      int outCount = 0;

      // copy all the entries except the one to be deleted
      ZipEntry entry = inStream.getNextEntry();
      while (entry != null) {
        inCount++;
        if (!this.getZipEntryName().equals(entry.getName())) {
          outCount++;
          outStream.putNextEntry(entry);
          int byteCount;
          while ((byteCount = inStream.read(buffer)) != -1) {
            outStream.write(buffer, 0, byteCount);
          }
          outStream.closeEntry();
        }
        entry = inStream.getNextEntry();
      }
      inStream.close();
      if (outCount == 0) {
        // add a dummy record to an empty file so we can close it
        // this is required by ZipOutputStream
        outStream.putNextEntry(new ZipEntry("delete.txt"));
        outStream.write(
            "This file is a place-holder. The containing ZIP file should be deleted.".getBytes());
        outStream.closeEntry();
      }
      outStream.close();
      if (outCount == inCount) {
        // no entries were removed - just delete the temp file
        outFile.delete();
      } else {
        // at least one entry removed - delete the original file
        this.getFile().delete();
        if (outCount == 0) {
          // NO entries remain - just delete the temp file too
          outFile.delete();
        } else {
          // entries remain - replace original file with temp file
          outFile.renameTo(this.getFile());
        }
      }
      return new Integer(inCount - outCount); // should be 0 or 1
    } catch (IOException ex) {
      throw XMLDataStoreException.ioException(ex);
    }
  }
  private void checkAndLaunchUpdate() {
    Log.i(LOG_FILE_NAME, "Checking for an update");

    int statusCode = 8; // UNEXPECTED_ERROR
    File baseUpdateDir = null;
    if (Build.VERSION.SDK_INT >= 8)
      baseUpdateDir = getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS);
    else baseUpdateDir = new File(Environment.getExternalStorageDirectory().getPath(), "download");

    File updateDir = new File(new File(baseUpdateDir, "updates"), "0");

    File updateFile = new File(updateDir, "update.apk");
    File statusFile = new File(updateDir, "update.status");

    if (!statusFile.exists() || !readUpdateStatus(statusFile).equals("pending")) return;

    if (!updateFile.exists()) return;

    Log.i(LOG_FILE_NAME, "Update is available!");

    // Launch APK
    File updateFileToRun = new File(updateDir, getPackageName() + "-update.apk");
    try {
      if (updateFile.renameTo(updateFileToRun)) {
        String amCmd =
            "/system/bin/am start -a android.intent.action.VIEW "
                + "-n com.android.packageinstaller/.PackageInstallerActivity -d file://"
                + updateFileToRun.getPath();
        Log.i(LOG_FILE_NAME, amCmd);
        Runtime.getRuntime().exec(amCmd);
        statusCode = 0; // OK
      } else {
        Log.i(LOG_FILE_NAME, "Cannot rename the update file!");
        statusCode = 7; // WRITE_ERROR
      }
    } catch (Exception e) {
      Log.i(LOG_FILE_NAME, "error launching installer to update", e);
    }

    // Update the status file
    String status = statusCode == 0 ? "succeeded\n" : "failed: " + statusCode + "\n";

    OutputStream outStream;
    try {
      byte[] buf = status.getBytes("UTF-8");
      outStream = new FileOutputStream(statusFile);
      outStream.write(buf, 0, buf.length);
      outStream.close();
    } catch (Exception e) {
      Log.i(LOG_FILE_NAME, "error writing status file", e);
    }

    if (statusCode == 0) System.exit(0);
  }
Exemple #19
0
 private static void backupByDate(String filename, File oldest) {
   SimpleDateFormat justDateFmt = new SimpleDateFormat("ddMMMyy");
   String justDate = justDateFmt.format(new Date());
   String oldBackup = makeBackupFilename(filename, justDate);
   File oldDateBackup = new File(oldBackup);
   if (oldDateBackup.exists()) {
     oldDateBackup.delete();
     File newDateBackup = new File(oldBackup);
     oldest.renameTo(newDateBackup);
   } else {
     oldest.renameTo(oldDateBackup);
     String oldestByDate = JConfig.queryConfiguration("save.bydate.4", "");
     for (int i = 4; i > 0; i--) {
       JConfig.setConfiguration(
           "save.bydate." + i, JConfig.queryConfiguration("save.bydate." + (i - 1), ""));
     }
     JConfig.setConfiguration("save.bydate.0", oldBackup);
     File deleteMe = new File(oldestByDate);
     deleteMe.delete();
   }
 }
  private void saveData(TelemetryData data) {
    PrintWriter out;
    boolean newFile = false;

    if (saveCnt > 25000) {
      File logFile;
      int i;

      logFile = new File(telemetryDir + 99 + ".log");
      logFile.delete();
      newFile = true;

      for (i = 99; i > 0; i--) {
        logFile = new File(telemetryDir + (i - 1) + ".log");
        logFile.renameTo(new File(telemetryDir + i + ".log"));
      }
      saveCnt = 0;
    }

    try {
      String text = "";
      SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.GERMAN);

      saveCnt++;
      out = new PrintWriter(new FileOutputStream(telemetryDir + "0.log", true));
      if (newFile) {
        text =
            "Time\tLatitude\tLongitude\tSpeed\tAcceleration X\tAcceleration Y\tAcceleration Z\tCoG\tOrientation Y\tOrientation Z\n\n";
        out.print(text);
      }
      text = dateFormat.format(new Date(System.currentTimeMillis())) + "\t";
      if (posValid) text = text + lastLat + "\t" + lastLon + "\t" + m_lastSpeed + "\t";
      else text = text + "-\t-\t-\t";
      text =
          text
              + data.getAccelX()
              + "\t"
              + data.getAccelY()
              + "\t"
              + data.getAccelZ()
              + "\t"
              + data.CoG
              + "\t"
              + data.getOrientY()
              + "\t"
              + data.getOrientZ()
              + "\n\n";
      out.print(text);
      out.close();
    } catch (IOException ioe) {
    }
  }
Exemple #21
0
 private void tidyFileAway(File f, String extension) {
   File rename = new File(f.getAbsolutePath() + "." + extension);
   while (rename.exists()) {
     rename = new File(rename.getAbsolutePath() + "." + extension);
   }
   getLog()
       .warn(
           "Tidying " + f.getAbsolutePath() + " out of the way, by adding ." + extension,
           "It will be called: "
               + rename.getAbsolutePath()
               + " see log above for detail of problem.");
   f.renameTo(rename);
 }
Exemple #22
0
 private void seizeExternal() {
   try {
     File srcFile = new File(mmPath);
     File destFile = new File(mContext.getExternalFilesDir(null), srcFile.getName());
     if (!srcFile.renameTo(destFile)) {
       throw new IOException(
           String.format(
               "cannot rename %s to %s", srcFile.getAbsolutePath(), destFile.getAbsolutePath()));
     }
     mmPath = destFile.getAbsolutePath();
   } catch (IOException e) {
     throw new RuntimeException(e);
   }
 }
 /**
  * (Re)generate the target {@linkplain Properties properties} file.
  *
  * @throws IOException If an exceptional situation arises while reading properties.
  */
 public void generate() throws IOException {
   // Force correct initialization order... sigh.
   AvailRuntime.nextHash();
   final File fileName =
       new File(
           String.format(
               "src/%s_%s.properties", baseName.replace('.', '/'), locale.getLanguage()));
   System.out.println(fileName.getAbsolutePath());
   final String[] components = baseName.split("\\.");
   final File tempFileName =
       new File(
           String.format(
               "%s/%s_%s.propertiesTEMP",
               System.getProperty("java.io.tmpdir"),
               components[components.length - 1],
               locale.getLanguage()));
   assert fileName.getPath().endsWith(".properties");
   final Properties properties = new Properties();
   try (final FileInputStream inputStream = new FileInputStream(fileName)) {
     try (final InputStreamReader reader =
         new InputStreamReader(inputStream, StandardCharsets.UTF_8)) {
       properties.load(reader);
     }
   } catch (final FileNotFoundException e) {
     // Ignore. It's okay if the file doesn't already exist.
   }
   final PrintWriter writer = new PrintWriter(tempFileName, "UTF-8");
   generatePreamble(writer);
   generateProperties(properties, writer);
   writer.close();
   // Now switch the new file in.  In the rare event of failure between
   // these steps, the complete content will still be available in the
   // corresponding *.propertiesTEMP file.
   boolean worked = fileName.delete();
   if (!worked) {
     System.err.println(
         String.format("deleting the original properties file failed: %s", fileName));
   }
   worked = tempFileName.renameTo(fileName);
   if (!worked) {
     throw new RuntimeException(
         String.format(
             "moving the temporary properties file failed: %s -> %s", tempFileName, fileName));
   }
 }
  /** par: filename for the level.dat_mcr backup */
  private void createFile(String par1Str) {
    File file = new File(savesDirectory, par1Str);

    if (!file.exists()) {
      System.out.println("Warning: Unable to create level.dat_mcr backup");
      return;
    }

    File file1 = new File(file, "level.dat");

    if (!file1.exists()) {
      System.out.println("Warning: Unable to create level.dat_mcr backup");
      return;
    }

    File file2 = new File(file, "level.dat_mcr");

    if (!file1.renameTo(file2)) {
      System.out.println("Warning: Unable to create level.dat_mcr backup");
    }
  }
Exemple #25
0
 private long persist(File f, ObjectName name) {
   long deployed = f.lastModified();
   try {
     Element e = (Element) server.getAttribute(name, "Persist");
     if (e != null) {
       XMLOutputter out = new XMLOutputter(Format.getPrettyFormat());
       Document doc = new Document();
       e.detach();
       doc.setRootElement(e);
       File tmp = new File(f.getAbsolutePath() + ".tmp");
       FileWriter writer = new FileWriter(tmp);
       out.output(doc, writer);
       writer.close();
       f.delete();
       tmp.renameTo(f);
       deployed = f.lastModified();
     }
   } catch (Exception ex) {
     log.warn("persist", ex);
   }
   return deployed;
 }
Exemple #26
0
 protected void saveState() throws TeamException {
   IPath pluginStateLocation = CVSUIPlugin.getPlugin().getStateLocation();
   File tempFile =
       pluginStateLocation.append(REPOSITORIES_VIEW_FILE + ".tmp").toFile(); // $NON-NLS-1$
   File stateFile = pluginStateLocation.append(REPOSITORIES_VIEW_FILE).toFile();
   try {
     XMLWriter writer = new XMLWriter(new BufferedOutputStream(new FileOutputStream(tempFile)));
     try {
       writeState(writer);
     } finally {
       writer.close();
     }
     if (stateFile.exists()) {
       stateFile.delete();
     }
     boolean renamed = tempFile.renameTo(stateFile);
     if (!renamed) {
       throw new TeamException(
           new Status(
               IStatus.ERROR,
               CVSUIPlugin.ID,
               TeamException.UNABLE,
               NLS.bind(
                   CVSUIMessages.RepositoryManager_rename,
                   new String[] {tempFile.getAbsolutePath()}),
               null));
     }
   } catch (IOException e) {
     throw new TeamException(
         new Status(
             IStatus.ERROR,
             CVSUIPlugin.ID,
             TeamException.UNABLE,
             NLS.bind(
                 CVSUIMessages.RepositoryManager_save, new String[] {stateFile.getAbsolutePath()}),
             e));
   }
 }
  @Nullable
  private static File renameToTempFileOrDelete(@NotNull File file) {
    final File tempDir = new File(getTempDirectory());
    boolean isSameDrive = true;
    if (SystemInfo.isWindows) {
      String tempDirDrive = tempDir.getAbsolutePath().substring(0, 2);
      String fileDrive = file.getAbsolutePath().substring(0, 2);
      isSameDrive = tempDirDrive.equalsIgnoreCase(fileDrive);
    }

    if (isSameDrive) {
      // the optimization is reasonable only if destination dir is located on the same drive
      final String originalFileName = file.getName();
      File tempFile = getTempFile(originalFileName, tempDir);
      if (file.renameTo(tempFile)) {
        return tempFile;
      }
    }

    delete(file);

    return null;
  }
Exemple #28
0
 @Override
 public void save() {
   NBTOutputStream stream = null;
   try {
     Files.createParentDirs(this.file);
     final File temporaryFile =
         File.createTempFile(this.file.getName(), null, this.file.getParentFile());
     temporaryFile.deleteOnExit();
     stream = new NBTOutputStream(new FileOutputStream(temporaryFile));
     stream.writeTag(new CompoundTag(this.name, this.root));
     stream.close();
     this.file.delete();
     temporaryFile.renameTo(this.file);
     temporaryFile.delete();
   } catch (IOException ex) {
     ex.printStackTrace();
   } finally {
     try {
       stream.close();
     } catch (IOException ex2) {
     }
   }
 }
Exemple #29
0
  public static boolean move(File source, File destination) {
    if (!source.exists()) {
      return false;
    }

    // If both files exists and are equals no need to move it.
    try {
      // Confirms that destination exists.
      if (destination.exists()) {
        // Creates FileInputStream for both files.
        FileInputStream inputSource = new FileInputStream(source);
        FileInputStream inputDestination = new FileInputStream(destination);

        // Both files checked.
        if (DigestUtils.md5Hex(inputSource).equals(DigestUtils.md5Hex(inputDestination))) {
          Logger.info(FileUtil.class, "Move method: Source equal to Destination, no need to move.");
          return true;
        }
      }
    } catch (Exception e) {
      // In case of error, no worries. Continued with the same logic of move.
      Logger.debug(FileUtil.class, "MD5 Checksum failed, continue with standard move");
    }

    destination.delete();

    boolean success = source.renameTo(destination);

    // if the rename fails, copy

    if (!success) {
      copyFile(source, destination);
      success = source.delete();
    }
    return success;
  }
Exemple #30
0
  private void cleanup(File directory) {
    // Clean up from old installations, removing or renaming files.
    // Note that directory is the parent of the CTP directory
    // unless the original installation was done by Bill Weadock's
    // all-in-one installer for Windows.

    // Get a file pointing to the CTP directory.
    // This might be the current directory, or
    // it might be the CTP child.
    File dir;
    if (directory.getName().equals("RSNA")) dir = directory;
    else dir = new File(directory, "CTP");

    // If CTP.jar exists in this directory, it is a really
    // old CTP main file - not used anymore
    File ctp = new File(dir, "CTP.jar");
    if (ctp.exists()) ctp.delete();

    // These are old names for the Launcher.jar file
    File launcher = new File(dir, "CTP-launcher.jar");
    if (launcher.exists()) launcher.delete();
    launcher = new File(dir, "TFS-launcher.jar");
    if (launcher.exists()) launcher.delete();

    // Delete the obsolete CTP-runner.jar file
    File runner = new File(dir, "CTP-runner.jar");
    if (runner.exists()) runner.delete();

    // Delete the obsolete MIRC-copier.jar file
    File copier = new File(dir, "MIRC-copier.jar");
    if (copier.exists()) copier.delete();

    // Rename the old versions of the properties files
    File oldprops = new File(dir, "CTP-startup.properties");
    File newprops = new File(dir, "CTP-launcher.properties");
    File correctprops = new File(dir, "Launcher.properties");
    if (oldprops.exists()) {
      if (newprops.exists() || correctprops.exists()) oldprops.delete();
      else oldprops.renameTo(correctprops);
    }
    if (newprops.exists()) {
      if (correctprops.exists()) newprops.delete();
      else newprops.renameTo(correctprops);
    }

    // Get rid of obsolete startup and shutdown programs
    File startup = new File(dir, "CTP-startup.jar");
    if (startup.exists()) startup.delete();
    File shutdown = new File(dir, "CTP-shutdown.jar");
    if (shutdown.exists()) shutdown.delete();

    // Get rid of the obsolete linux directory
    File linux = new File(dir, "linux");
    if (linux.exists()) {
      startup = new File(linux, "CTP-startup.jar");
      if (startup.exists()) startup.delete();
      shutdown = new File(linux, "CTP-shutdown.jar");
      if (shutdown.exists()) shutdown.delete();
      linux.delete();
    }

    // clean up the libraries directory
    File libraries = new File(dir, "libraries");
    if (libraries.exists()) {
      // remove obsolete versions of the slf4j libraries
      // and the dcm4che-imageio libraries
      File[] files = libraries.listFiles();
      for (File file : files) {
        if (file.isFile()) {
          String name = file.getName();
          if (name.startsWith("slf4j-") || name.startsWith("dcm4che-imageio-rle")) {
            file.delete();
          }
        }
      }
      // remove the email subdirectory
      File email = new File(libraries, "email");
      deleteAll(email);
      // remove the xml subdirectory
      File xml = new File(libraries, "xml");
      deleteAll(xml);
      // remove the sftp subdirectory
      File sftp = new File(libraries, "sftp");
      deleteAll(xml);
      // move edtftpj.jar to the ftp directory
      File edtftpj = new File(libraries, "edtftpj.jar");
      if (edtftpj.exists()) {
        File ftp = new File(libraries, "ftp");
        ftp.mkdirs();
        File ftpedtftpj = new File(ftp, "edtftpj.jar");
        edtftpj.renameTo(ftpedtftpj);
      }
    }

    // remove the obsolete xml library under dir
    File xml = new File(dir, "xml");
    deleteAll(xml);

    // remove the dicom profiles so any
    // obsolete files will disappear
    File profiles = new File(dir, "profiles");
    File dicom = new File(profiles, "dicom");
    deleteAll(dicom);
    dicom.mkdirs();

    // Remove the index.html file so it will be rebuilt from
    // example-index.html when the system next starts.
    File root = new File(dir, "ROOT");
    if (root.exists()) {
      File index = new File(root, "index.html");
      index.delete();
    }
  }