include/proxy/logging/LogFile.h

/** @file

  A brief file description

  @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 "tscore/ink_platform.h"
#include "proxy/logging/LogBufferSink.h"

class LogBuffer;
struct LogBufferHeader;
class LogObject;
class BaseLogFile;
class BaseMetaInfo;

/*-------------------------------------------------------------------------
  LogFile
  -------------------------------------------------------------------------*/

class LogFile : public LogBufferSink, public RefCountObjInHeap
{
public:
  LogFile(const char *name, const char *header, LogFileFormat format, uint64_t signature, size_t ascii_buffer_size = 4 * 9216,
          size_t max_line_size = 9216, int pipe_buffer_size = 0, LogEscapeType escape_type = LOG_ESCAPE_NONE);
  LogFile(const LogFile &) = delete;
  ~LogFile() override;

  enum {
    LOG_FILE_NO_ERROR = 0,
    LOG_FILE_NO_PIPE_READERS,
    LOG_FILE_COULD_NOT_CREATE_PIPE,
    LOG_FILE_PIPE_MODE_NOT_SUPPORTED,
    LOG_FILE_COULD_NOT_OPEN_FILE,
    LOG_FILE_FILESYSTEM_CHECKS_FAILED
  };

  int preproc_and_try_delete(LogBuffer *lb) override;

  bool trim_rolled(size_t rolling_max_count);
  int  roll(long interval_start, long interval_end, bool reopen_after_rolling = false);

  /** Check whether the file at the log's filename exists and, if not, close
   * the current file descriptor and reopen it.
   *
   * @return True if the file was re-opened, false otherwise.
   */
  bool reopen_if_moved();

  const char *
  get_name() const
  {
    return m_name;
  }

  void change_header(const char *header);
  void change_name(const char *new_name);

  LogFileFormat
  get_format() const
  {
    return m_file_format;
  }

  LogEscapeType
  get_escape_type() const
  {
    return m_escape_type;
  }

  const char *
  get_format_name() const
  {
    return (m_file_format == LOG_FILE_BINARY ? "binary" : (m_file_format == LOG_FILE_PIPE ? "ascii_pipe" : "ascii"));
  }

  static int  write_ascii_logbuffer(LogBufferHeader *buffer_header, int fd, const char *path, const char *alt_format = nullptr);
  int         write_ascii_logbuffer3(LogBufferHeader *buffer_header, const char *alt_format = nullptr);
  static bool rolled_logfile(char *file);
  static bool exists(const char *pathname);

  void display(FILE *fd = stdout);
  int  open_file();

  off_t
  get_size_bytes() const
  {
    if (m_file_format == LOG_FILE_PIPE)
      return 0;
    else if (m_log)
      return m_log->get_size_bytes();
    else
      return 0;
  }

public:
  bool       is_open();
  void       close_file();
  void       check_fd();
  int        get_fd();
  static int writeln(char *data, int len, int fd, const char *path);

public:
  LogFileFormat m_file_format;

private:
  char         *m_name;
  LogEscapeType m_escape_type;

public:
  std::unique_ptr<BaseLogFile> m_log; // BaseLogFile backs the actual file on disk
  char                        *m_header;
  uint64_t                     m_signature;         // signature of log object stored
  size_t                       m_ascii_buffer_size; // size of ascii buffer
  size_t                       m_max_line_size;     // size of longest log line (record)
  int                          m_pipe_buffer_size;  // this is the size of the pipe buffer set by fcntl
  int                          m_fd;                // this could back m_log or a pipe, depending on the situation

public:
  Link<LogFile> link;
  // noncopyable
  LogFile &operator=(const LogFile &) = delete;

private:
  // -- member functions not allowed --
  LogFile();
};