content: /*
   * Copyright (C) 2009 The Android Open Source Project
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package com.android.internal.os;
  
  import android.annotation.UnsupportedAppUsage;
  import android.os.Build;
  import android.os.FileUtils;
  import android.util.Log;
  
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileNotFoundException;
  import java.io.FileOutputStream;
  import java.io.IOException;
  
  /**
   * Helper class for performing atomic operations on a file, by creating a
   * backup file until a write has successfully completed.
   * <p>
   * Atomic file guarantees file integrity by ensuring that a file has
   * been completely written and sync'd to disk before removing its backup.
   * As long as the backup file exists, the original file is considered
   * to be invalid (left over from a previous attempt to write the file).
   * </p><p>
   * Atomic file does not confer any file locking semantics.
   * Do not use this class when the file may be accessed or modified concurrently
   * by multiple threads or processes.  The caller is responsible for ensuring
   * appropriate mutual exclusion invariants whenever it accesses the file.
   * </p>
   */
  public final class AtomicFile {
      private final File mBaseName;
      private final File mBackupName;
      
      @UnsupportedAppUsage
      public AtomicFile(File baseName) {
          mBaseName = baseName;
          mBackupName = new File(baseName.getPath() + ".bak");
      }
      
      @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P, trackingBug = 115609023)
      public File getBaseFile() {
          return mBaseName;
      }
      
      @UnsupportedAppUsage
      public FileOutputStream startWrite() throws IOException {
          // Rename the current file so it may be used as a backup during the next read
          if (mBaseName.exists()) {
              if (!mBackupName.exists()) {
                  if (!mBaseName.renameTo(mBackupName)) {
                      Log.w("AtomicFile", "Couldn't rename file " + mBaseName
                              + " to backup file " + mBackupName);
                  }
              } else {
                  mBaseName.delete();
              }
          }
          FileOutputStream str = null;
          try {
              str = new FileOutputStream(mBaseName);
          } catch (FileNotFoundException e) {
              File parent = mBaseName.getParentFile();
              if (!parent.mkdir()) {
                  throw new IOException("Couldn't create directory " + mBaseName);
              }
              FileUtils.setPermissions(
                  parent.getPath(),
                  FileUtils.S_IRWXU|FileUtils.S_IRWXG|FileUtils.S_IXOTH,
                  -1, -1);
              try {
                  str = new FileOutputStream(mBaseName);
              } catch (FileNotFoundException e2) {
                  throw new IOException("Couldn't create " + mBaseName);
              }
          }
          return str;
      }
      
      @UnsupportedAppUsage
      public void finishWrite(FileOutputStream str) {
          if (str != null) {
              FileUtils.sync(str);
              try {
                  str.close();
                  mBackupName.delete();
              } catch (IOException e) {
                  Log.w("AtomicFile", "finishWrite: Got exception:", e);
              }
          }
      }
      
      @UnsupportedAppUsage
      public void failWrite(FileOutputStream str) {
          if (str != null) {
              FileUtils.sync(str);
              try {
                  str.close();
                  mBaseName.delete();
                  mBackupName.renameTo(mBaseName);
              } catch (IOException e) {
                  Log.w("AtomicFile", "failWrite: Got exception:", e);
              }
          }
      }
      
      @UnsupportedAppUsage
      public FileOutputStream openAppend() throws IOException {
          try {
              return new FileOutputStream(mBaseName, true);
          } catch (FileNotFoundException e) {
              throw new IOException("Couldn't append " + mBaseName);
          }
      }
      
      @UnsupportedAppUsage
      public void truncate() throws IOException {
          try {
              FileOutputStream fos = new FileOutputStream(mBaseName);
              FileUtils.sync(fos);
              fos.close();
          } catch (FileNotFoundException e) {
              throw new IOException("Couldn't append " + mBaseName);
          } catch (IOException e) {
          }
      }
  
      public boolean exists() {
          return mBaseName.exists() || mBackupName.exists();
      }
  
      public void delete() {
          mBaseName.delete();
          mBackupName.delete();
      }
  
      @UnsupportedAppUsage
      public FileInputStream openRead() throws FileNotFoundException {
          if (mBackupName.exists()) {
              mBaseName.delete();
              mBackupName.renameTo(mBaseName);
          }
          return new FileInputStream(mBaseName);
      }
      
      @UnsupportedAppUsage
      public byte[] readFully() throws IOException {
          FileInputStream stream = openRead();
          try {
              int pos = 0;
              int avail = stream.available();
              byte[] data = new byte[avail];
              while (true) {
                  int amt = stream.read(data, pos, data.length-pos);
                  //Log.i("foo", "Read " + amt + " bytes at " + pos
                  //        + " of avail " + data.length);
                  if (amt <= 0) {
                      //Log.i("foo", "**** FINISHED READING: pos=" + pos
                      //        + " len=" + data.length);
                      return data;
                  }
                  pos += amt;
                  avail = stream.available();
                  if (avail > data.length-pos) {
                      byte[] newData = new byte[pos+avail];
                      System.arraycopy(data, 0, newData, 0, pos);
                      data = newData;
                  }
              }
          } finally {
              stream.close();
          }
      }
  }
  