root/trunk/whisperlib/common/io/file/file.cc

// Copyright (c) 2009, Whispersoft s.r.l.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Whispersoft s.r.l. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Author: Cosmin Tudorache

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "common/base/log.h"
#include "common/base/common.h"
#include "common/base/errno.h"

#include "common/io/file/file.h"
#include "common/io/file/fd.h"

namespace io {

const char* File::AccessName(Access access) {
  switch ( access ) {
    CONSIDER(GENERIC_READ);
    CONSIDER(GENERIC_WRITE);
    CONSIDER(GENERIC_READ_WRITE);
  }
  return "UnknownAccess";
}

const char* File::CreationDispositionName(CreationDisposition cd) {
  switch ( cd ) {
    CONSIDER(CREATE_ALWAYS);
    CONSIDER(CREATE_NEW);
    CONSIDER(OPEN_ALWAYS);
    CONSIDER(OPEN_EXISTING);
    CONSIDER(TRUNCATE_EXISTING);
  }
  return "UnknownCreationDisposition";
}

const char* File::MoveMethodName(MoveMethod mm) {
  switch ( mm ) {
    CONSIDER(FILE_SET);
    CONSIDER(FILE_CUR);
    CONSIDER(FILE_END);
  }
  return "UnknownMoveMethod";
}

File::File()
  : filename_(""),
    fd_(INVALID_FD_VALUE),
    size_(-1),
    position_(-1) {
}

File::~File() {
  if ( is_open() )
    Close();
}

File* File::OpenFileOrDie(const char* filename) {
  File* const f = new File();
  CHECK(f->Open(filename, GENERIC_READ, OPEN_EXISTING));
  return f;
}

File* File::TryOpenFile(const char* filename) {
  File* const f = new File();
  if ( !f->Open(filename, GENERIC_READ, OPEN_EXISTING) ) {
    delete f;
    return NULL;
  }
  return f;
}

File* File::CreateFileOrDie(const char* filename) {
  File* const f = new File();
  CHECK(f->Open(filename, GENERIC_READ_WRITE, CREATE_ALWAYS));
  return f;
}
File* File::TryCreateFile(const char* filename) {
  File* const f = new File();
  if ( !f->Open(filename, GENERIC_READ_WRITE, CREATE_ALWAYS) ) {
    delete f;
    return NULL;
  }
  return f;
}


bool File::Open(const char* filename,  Access access, CreationDisposition cd) {
  CHECK(!is_open());

  int flags = O_NOCTTY | O_LARGEFILE;
  switch ( cd ) {
  case CREATE_ALWAYS:     flags |= O_CREAT | O_TRUNC; break;
  case CREATE_NEW:        flags |= O_CREAT | O_EXCL; break;
  case OPEN_ALWAYS:       flags |= O_CREAT; break;
  case OPEN_EXISTING:     flags |= 0; break;
  case TRUNCATE_EXISTING: flags |= O_TRUNC; break;
  default:
    LOG_FATAL << filename << " - Invalid Disposition: " << cd;
  };

  mode_t mode = 0;
  switch (access)  {
  case GENERIC_READ:       flags |= O_RDONLY; mode = 00444; break;
  case GENERIC_WRITE:      flags |= O_WRONLY; mode = 00200; break;
  case GENERIC_READ_WRITE: flags |= O_RDWR;   mode = 00644; break;
  default:
    LOG_FATAL << filename << " Invalid Access: " << access;
  };
  flags |= O_LARGEFILE;

  const int fd = ::open(filename, flags, mode);
  if ( fd == INVALID_FD_VALUE ) {
    LOG_ERROR << "Cannot open file " << filename
              << " using access: " << AccessName(access)
              << " creationDisposition: " << CreationDispositionName(cd)
              << " reason: " << GetLastSystemErrorDescription();
    return false;
  }

  filename_ = filename;
  fd_ = fd;
  UpdateSize();
  UpdatePosition();

  return true;
}

void File::Close() {
  CHECK(is_open());
  if ( ::close(fd_) < 0 ) {
    LOG_ERROR << filename_ << " - Error closing file."
              << " Reason: " << GetLastSystemErrorDescription();
  }
  fd_ = INVALID_FD_VALUE;
  filename_.clear();
}

int64 File::Size() const {
  CHECK(is_open());
  return size_;
}

int64 File::Position() const {
  CHECK(is_open());
  return position_;
}

int64 File::SetPosition(int64 distance,
                        MoveMethod move_method) {
  CHECK(is_open());
  int whence = SEEK_SET;
  switch ( move_method ) {
  case FILE_SET: whence = SEEK_SET; break;
  case FILE_CUR: whence = SEEK_CUR; break;
  case FILE_END: whence = SEEK_END; break;
  default:
    LOG_FATAL << filename_ << " Invalid MoveMethod : " << move_method;
  }

  const int64 crt = ::lseek64(fd_, distance, whence);
  if ( crt == -1 ) {
    LOG_ERROR << filename_ << " lseek64 failed "
              << GetLastSystemErrorDescription();
    return -1;
  }
  // update cached position_
  position_ = crt;
  return position_;
}

int32 File::Read(void* buf, int32 len) {
  CHECK(is_open()) << filename_;
  FileDescriptor fdesc;
  CHECK(fdesc.OpenFD(fd()));
  const int32 cb = fdesc.Read(buf, len);
  if ( cb < 0 ) {
    LOG_ERROR << filename_ << " Read Error encountered.";
    return cb;
  } else {
    position_ += cb;
    CHECK_LE(position_, size_);
  }
  return cb;
}

int32 File::Write(const void* buf, int32 len) {
  CHECK(is_open()) << filename_;
  FileDescriptor fdesc;
  CHECK(fdesc.OpenFD(fd()));
  const int32 cb = fdesc.Write(buf, len);
  if ( cb < 0 ) {
    LOG_ERROR << filename_ << " Write Error encountered.";
    UpdatePosition();  // don't know where the file pointer ended-up
  }
  return cb;
}

void File::Flush() {
  CHECK(is_open()) << filename_;
  // Well this should not happen - we are screwed otherwise
  CHECK_NE(::fdatasync(fd()), -1) << filename_ << " Failed on Flush. "
                                  << GetLastSystemErrorDescription();
}


int64 File::UpdateSize() {
  const int64 crt = ::lseek64(fd_, 0, SEEK_CUR);
  CHECK_NE(crt, -1) << GetLastSystemErrorDescription();
  size_ =  ::lseek64(fd_, 0, SEEK_END);
  CHECK_NE(size_, -1) << GetLastSystemErrorDescription();
  CHECK_EQ(::lseek64(fd_, crt, SEEK_SET), crt)
    << GetLastSystemErrorDescription();
  return size_;
}

int64 File::UpdatePosition() {
  position_ = ::lseek64(fd_, 0, SEEK_CUR);
  CHECK_NE(position_, -1) << GetLastSystemErrorDescription();
  return position_;
}
}