include/tscore/BaseLogFile.h

/** @file

  Base class for log files

  @section license License

  Licensed to the Apache Software Foundation (ASF) under one
  or more contributor license agreements.  See the NOTICE file
  distributed with this work for additional information
  regarding copyright ownership.  The ASF licenses this file
  to you 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.

 */

#pragma once

#include <cstdarg>
#include <cstdio>
#include <sys/time.h>
#include <cstdint>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#include "tscore/ink_memory.h"
#include "tscore/ink_string.h"
#include "tscore/ink_file.h"
#include "tscore/ink_cap.h"
#include "tscore/ink_time.h"
#include "tscore/SimpleTokenizer.h"

#define LOGFILE_ROLLED_EXTENSION ".old"
#define LOGFILE_SEPARATOR_STRING "_"
#define LOGFILE_DEFAULT_PERMS    (0644)
#define LOGFILE_ROLL_MAXPATHLEN  4096
#define BASELOGFILE_DEBUG_MODE \
  0 // change this to 1 to enable debug messages
    // TODO find a way to enable this from autotools

enum LogLogPriorityLevel {
  LL_Debug = 0, // process does not die
  LL_Note,      // process does not die
  LL_Warning,   // process does not die
  LL_Error,     // process does not die
  LL_Fatal,     // causes process termination
};

#define log_log_trace(...)                         \
  do {                                             \
    if (BASELOGFILE_DEBUG_MODE)                    \
      BaseLogFile::log_log(LL_Debug, __VA_ARGS__); \
  } while (0)

#define log_log_error(...)                         \
  do {                                             \
    if (BASELOGFILE_DEBUG_MODE)                    \
      BaseLogFile::log_log(LL_Error, __VA_ARGS__); \
  } while (0)

/*
 *
 * BaseMetaInfo class
 *
 * Used to store persistent information between ATS instances
 *
 */
class BaseMetaInfo
{
public:
  enum {
    DATA_FROM_METAFILE = 1, // metadata was read (or attempted to)
    // from metafile
    VALID_CREATION_TIME = 2, // creation time is valid
    VALID_SIGNATURE     = 4, // signature is valid
    // (i.e., creation time only)
    FILE_OPEN_SUCCESSFUL = 8 // metafile was opened successfully
  };

  enum {
    BUF_SIZE = 640 // size of read/write buffer
  };

private:
  char    *_filename{nullptr};       // the name of the meta file
  time_t   _creation_time{0};        // file creation time
  uint64_t _log_object_signature{0}; // log object signature
  int      _flags{0};                // metainfo status flags
  char     _buffer[BUF_SIZE];        // read/write buffer

  void _read_from_file();
  void _write_to_file();
  void _build_name(const char *filename);

public:
  BaseMetaInfo(const char *filename)
  {
    _build_name(filename);
    _read_from_file();
  }

  BaseMetaInfo(char *filename, time_t creation) : _creation_time(creation), _log_object_signature(0), _flags(VALID_CREATION_TIME)
  {
    _build_name(filename);
    _write_to_file();
  }

  BaseMetaInfo(char *filename, time_t creation, uint64_t signature)
    : _creation_time(creation), _log_object_signature(signature), _flags(VALID_CREATION_TIME | VALID_SIGNATURE)
  {
    _build_name(filename);
    _write_to_file();
  }

  ~BaseMetaInfo() { ats_free(_filename); }
  bool
  get_creation_time(time_t *time)
  {
    if (_flags & VALID_CREATION_TIME) {
      *time = _creation_time;
      return true;
    } else {
      return false;
    }
  }

  bool
  get_log_object_signature(uint64_t *signature)
  {
    if (_flags & VALID_SIGNATURE) {
      *signature = _log_object_signature;
      return true;
    } else {
      return false;
    }
  }

  bool
  data_from_metafile() const
  {
    return (_flags & DATA_FROM_METAFILE ? true : false);
  }

  bool
  file_open_successful()
  {
    return (_flags & FILE_OPEN_SUCCESSFUL ? true : false);
  }
};

/*
 *
 * BaseLogFile Class
 *
 */
class BaseLogFile
{
public:
  // member functions
  BaseLogFile()                               = delete;
  BaseLogFile &operator=(const BaseLogFile &) = delete;
  BaseLogFile(const char *name);
  BaseLogFile(const char *name, uint64_t sig);
  BaseLogFile(const BaseLogFile &);
  ~BaseLogFile();
  int         roll();
  int         roll(long interval_start, long interval_end);
  static bool rolled_logfile(char *path);
  static bool exists(const char *pathname);
  int         open_file(int perm = -1);
  int         close_file();
  void        change_name(const char *new_name);
  void        display(FILE *fd = stdout);
  const char *
  get_name() const
  {
    return m_name;
  }
  bool
  is_open()
  {
    return (m_fp != nullptr);
  }
  off_t
  get_size_bytes() const
  {
    return m_bytes_written;
  }
  bool
  is_init()
  {
    return m_is_init;
  }
  const char *
  get_hostname() const
  {
    return m_hostname;
  }
  void
  set_hostname(const char *hn)
  {
    m_hostname = ats_strdup(hn);
  }

  static void log_log(LogLogPriorityLevel priority, const char *format, ...);

  // member variables
  enum {
    LOG_FILE_NO_ERROR = 0,
    LOG_FILE_COULD_NOT_OPEN_FILE,
  };

  FILE    *m_fp            = nullptr;
  long     m_start_time    = time(nullptr);
  long     m_end_time      = 0L;
  uint64_t m_bytes_written = 0;

private:
  // member functions
  int timestamp_to_str(long timestamp, char *buf, int size);

  // member variables
  ats_scoped_str                m_name;
  ats_scoped_str                m_hostname;
  bool                          m_is_regfile    = false;
  bool                          m_is_init       = false;
  std::unique_ptr<BaseMetaInfo> m_meta_info     = nullptr;
  uint64_t                      m_signature     = 0;
  bool                          m_has_signature = false;
};