SshOutputCollector.h

Go to the documentation of this file.

/* -*- c++ -*-
 * Copyright (C) 2007-2014 Hypertable, Inc.
 *
 * This file is part of Hypertable.
 *
 * Hypertable 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 3
 * of the License, or any later version.
 *
 * Hypertable is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 */


#ifndef Tools_cluster_SshOutputCollector_h
#define Tools_cluster_SshOutputCollector_h

#include <Common/PageArena.h>
#include <Common/Logger.h>

#include <boost/iterator/iterator_facade.hpp>

#include <cstdlib>
#include <string>
#include <tuple>
#include <vector>

namespace Hypertable {


  class SshOutputCollector {

  public:

    class Buffer {
    public:
      Buffer() { }
      Buffer(char *buffer, size_t sz=0) : base(buffer), ptr(buffer), size(sz) { }
      size_t fill() const { return ptr-base; }
      size_t remain() const { return size-fill(); }
      void add(const char *data, size_t len) {
        HT_ASSERT(len <= remain());
        memcpy(ptr, data, len);
        ptr += len;
      }
      char *base {};
      char *ptr {};
      size_t size {};
    };

    class iterator : public boost::iterator_facade<iterator, const std::string, boost::forward_traversal_tag> {
    public:
      iterator(std::vector<Buffer> &buffers, size_t index=0) 
        : m_buffers(buffers), m_index(index), m_next_index(index) {
        increment();
      }

    private:
      friend class boost::iterator_core_access;

      void increment();

      bool equal(iterator const& other) const {
        return this->m_index == other.m_index &&
          this->m_offset == other.m_offset;
      }

      const std::string & dereference() const { return m_line; }

      std::vector<Buffer> &m_buffers;
      size_t m_index {};
      size_t m_offset {};
      size_t m_next_index {};
      size_t m_next_offset {};
      std::string m_line;
    };

    SshOutputCollector(size_t buffer_size) : m_buffer_size(buffer_size) {}

    size_t buffer_size() { return m_buffer_size; }

    Buffer allocate_buffer() {
      return Buffer(m_arena.alloc(m_buffer_size), m_buffer_size);
    }

    void add(Buffer buf) {
      if (buf.fill())
        m_buffers.push_back(buf);
    }

    bool empty() const {
      if (m_buffers.empty())
        return true;
      for (auto & buffer : m_buffers) {
        if (buffer.fill())
          return false;
      }
      return true;
    }

    bool last_line_is_partial() {
      HT_ASSERT(m_buffers.empty() || m_buffers.back().fill() > 0);
      return !m_buffers.empty() && *(m_buffers.back().ptr-1) != '\n';
    }

    iterator begin() { return iterator(m_buffers, 0); }

    iterator end() { return iterator(m_buffers, m_buffers.size()); }

  private:
    size_t m_buffer_size {};
    CharArena m_arena;
    std::vector<Buffer> m_buffers;
  };


} // namespace Hypertable

#endif // Tools_cluster_SshOutputCollector_h