heavy_file_ops.cpp

Go to the documentation of this file.

#ifndef HEAVY_FILE_OPS_IMPLEMENTATION_FILE
#define HEAVY_FILE_OPS_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : heavy file operations                                             *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 2005-$now By Author.  This program is free software; you can  *
* redistribute it and/or modify it under the terms of the GNU General Public  *
* License as published by the Free Software Foundation; either version 2 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

#include "directory.h"
#include "filename.h"
#include "filename_list.h"
#include "heavy_file_ops.h"
#include "huge_file.h"

#include <basis/function.h>
#include <basis/guards.h>
#include <basis/log_base.h>

using namespace basis;

#undef LOG
#define LOG(s) CLASS_EMERGENCY_LOG(program_wide_logger(), s)


file_transfer_header::file_transfer_header()
: _filename(),
  _byte_start(0),
  _length(0)
{
}

istring file_transfer_header::text_form() const
{
  return istring("file=") + _filename
      + isprintf(" start=%d len=%d", _byte_start, _length);
}

void file_transfer_header::pack(byte_array &packed_form) const
{
  _filename.pack(packed_form);
  attach(packed_form, _byte_start);
  attach(packed_form, _length);
}

bool file_transfer_header::unpack(byte_array &packed_form)
{
  if (!_filename.unpack(packed_form)) return false;
  if (!detach(packed_form, _byte_start)) return false;
  if (!detach(packed_form, _length)) return false;
  return true;
}

int file_transfer_header::packed_size() const
{
  return _filename.length() + 1
      + sizeof(int)
      + sizeof(int);
}


const size_t heavy_file_operations::COPY_CHUNK_FACTOR = 1 * MEGABYTE;

const size_t heavy_file_operations::copy_chunk_factor()
{ return COPY_CHUNK_FACTOR; }

heavy_file_operations::~heavy_file_operations() {}
  // we only need this due to our use of the object_base class_name support.

const char *heavy_file_operations::outcome_name(const outcome &to_name)
{
  switch (to_name.value()) {
    case SOURCE_MISSING: return "SOURCE_MISSING";
    case TARGET_ACCESS_ERROR: return "TARGET_ACCESS_ERROR";
    case TARGET_DIR_ERROR: return "TARGET_DIR_ERROR";
    default: return common::outcome_name(to_name);
  }
}

outcome heavy_file_operations::copy_file(const istring &source,
    const istring &destination, int copy_chunk_factor)
{
  FUNCDEF("copy_file");
  // check that the source exists...
  filename source_path(source);
  if (!source_path.exists()) return SOURCE_MISSING;

  // make sure the target directory exists...
  filename target_path(destination);
  filename targ_dir = target_path.dirname();
  if (!directory::recursive_create(targ_dir.raw())) return TARGET_DIR_ERROR;

  // open the source for reading.
  huge_file source_file(source, "rb");
  if (!source_file.good()) return SOURCE_MISSING;
//hmmm: could be source is not accessible instead.

  // open target file for writing.
  huge_file target_file(destination, "wb");
  if (!target_file.good()) return TARGET_ACCESS_ERROR;

  byte_array chunk;
  int bytes_read = 0;
  outcome ret;
  while ( (ret = source_file.read(chunk, copy_chunk_factor, bytes_read))
      == huge_file::OKAY) {
    int bytes_stored;
    ret = target_file.write(chunk, bytes_stored);
    if (bytes_stored != bytes_read) return TARGET_ACCESS_ERROR;
    if (source_file.eof()) break;  // time to escape.
  }

  return OKAY;
}

outcome heavy_file_operations::write_file_chunk(const istring &target,
    double byte_start, const byte_array &chunk, bool truncate,
    int copy_chunk_factor)
{
  FUNCDEF("write_file_chunk");
  if (byte_start < 0) return BAD_INPUT;

  filename targ_name(target);
  if (!directory::recursive_create(targ_name.dirname().raw()))
    return TARGET_DIR_ERROR;

  if (!targ_name.exists()) {
    huge_file target_file(target, "w");
  }

  huge_file target_file(target, "r+b");
    // open the file for updating (either read or write).
  if (!target_file.good()) return TARGET_ACCESS_ERROR;
  double curr_len = target_file.length();

  if (curr_len < byte_start) {
    byte_array new_chunk;
    while (curr_len < byte_start) {
      target_file.seek(0, byte_filer::FROM_END);  // go to the end of the file.
      new_chunk.reset(minimum(copy_chunk_factor,
          int(curr_len - byte_start + 1)));
      int written;
      outcome ret = target_file.write(new_chunk, written);
      if (written < new_chunk.length()) return TARGET_ACCESS_ERROR;
      curr_len = target_file.length();
    }
  }
  target_file.seek(byte_start, byte_filer::FROM_START);
    // jump to the proper location in the file.
  int wrote;
  outcome ret = target_file.write(chunk, wrote);
  if (wrote != chunk.length()) return TARGET_ACCESS_ERROR;
  if (truncate) {
    target_file.truncate();
  }
  return OKAY;
}

bool advance(const filename_list &to_transfer,
    file_transfer_header &last_action)
{
  int indy = to_transfer.locate(last_action._filename);
  if (negative(indy)) return false;  // error.
  if (indy == to_transfer.elements() - 1) return false;  // done.
  last_action._filename = to_transfer.get(indy + 1)->raw();
  last_action._byte_start = 0;
  last_action._length = 0;
  return true;
}

outcome heavy_file_operations::buffer_files(const istring &source_root,
    const filename_list &to_transfer, file_transfer_header &last_action,
    byte_array &storage, int maximum_bytes)
{
  FUNCDEF("buffer_files");
  storage.reset();  // clear out the current contents.

  if (!to_transfer.elements()) {
    // we seem to be done.
    return OKAY;
  }

  outcome to_return = OKAY;

  // start filling the array with bytes from the files.
  while (storage.length() < maximum_bytes) {
    double remaining_in_array = maximum_bytes - storage.length()
        - last_action.packed_size();
    if (remaining_in_array < 128) {
      // ensure that we at least have a reasonable amount of space left
      // for storing into the array.
      break;
    }

    // find the current file we're at, as provided in record.
    if (!last_action._filename) {
      // no filename yet.  assume this is the first thing we've done.
      last_action._filename = to_transfer.get(0)->raw();
      last_action._byte_start = 0;
      last_action._length = 0;
    }

    const file_info *found = to_transfer.find(last_action._filename);
    if (!found) {
      // they have referenced a file that we don't have.  that's bad news.
      return BAD_INPUT;
    }

    istring full_file = source_root + "/" + last_action._filename;
    huge_file current(full_file, "rb");
    if (!current.good()) {
      // we need to skip this file.
      if (!advance(to_transfer, last_action)) break;
      continue;
    }

    if ((last_action._byte_start + last_action._length >= current.length())
        && current.length()) {
      // this file is done now.  go to the next one.
      if (!advance(to_transfer, last_action)) break;
      continue;
    }

    // calculate the largest piece remaining of that file that will fit in the
    // allotted space.
    double new_start = last_action._byte_start + last_action._length;
    double remaining_in_file = current.length() - new_start;
    if (remaining_in_file < 0) remaining_in_file = 0;
    double new_len = minimum(remaining_in_file, remaining_in_array);
    
    // pack this new piece of the file.
    current.seek(new_start, byte_filer::FROM_START);
    byte_array new_chunk;
    int bytes_read = 0;
    outcome ret = current.read(new_chunk, int(new_len), bytes_read);
    if (bytes_read != new_len) {
      if (!bytes_read) {
        // some kind of problem reading the file.
        if (!advance(to_transfer, last_action)) break;
        continue;
      }
//why would this happen?  just complain, i guess.
    }

    // update the record since it seems we're successful here.
    last_action._byte_start = new_start;
    last_action._length = int(new_len);

    // add in this next new chunk of file.
    last_action.pack(storage);  // add the header.
    storage += new_chunk;  // add the new stuff.

    if (!current.length()) {
      // ensure we don't get stuck redoing zero length files, which we allowed
      // to go past their end above (since otherwise we'd never see them).
      if (!advance(to_transfer, last_action)) break;
      continue;
    }
    
    // just keep going, if there's space...
  }

  return to_return;
}


#endif //HEAVY_FILE_OPS_IMPLEMENTATION_FILE

---