// system headers

#include <algorithm>

#include <iostream>

#include <memory>

#include <stdexcept>

#include <utility>

#include <unistd.h>

#include <thread>

// local headers

#include "linuxdeploy/subprocess/subprocess.h"

#include "linuxdeploy/subprocess/process.h"

#include "linuxdeploy/subprocess/pipe_reader.h"

#include "linuxdeploy/util/assert.h"

namespace linuxdeploy {

namespace subprocess {

subprocess::subprocess(std::initializer_list<std::string> args)

: subprocess(std::vector<std::string>(args), get_environment()) {}

subprocess::subprocess(std::initializer_list<std::string> args, subprocess_env_map_t env)

: subprocess(std::vector<std::string>(args), std::move(env)) {}

subprocess::subprocess(std::vector<std::string> args)

: args_(std::move(args)), env_(get_environment()) {}

subprocess::subprocess(std::vector<std::string> args, subprocess_env_map_t env)

: args_(std::move(args)), env_(std::move(env)) {

// preconditions

util::assert::assert_not_empty(args_);

}

subprocess_result subprocess::run() const {

process proc{args_, env_};

class PipeState {

public:

pipe_reader reader;

subprocess_result_buffer_t buffer;

bool eof = false;

explicit PipeState(int fd) : reader(fd) {}

};

// create pipe readers and empty buffers for both stdout and stderr

// we manage them in this (admittedly, kind of complex-looking) array so we can later easily perform the

// operations in a loop

std::array<PipeState, 2> buffers = {

PipeState(proc.stdout_fd()),

PipeState(proc.stderr_fd())

};

for (;;) {

for (auto& pipe_state : buffers) {

// read some bytes into smaller intermediate buffer to prevent either of the pipes to overflow

// the results are immediately appended to the main buffer

subprocess_result_buffer_t intermediate_buffer(4096);

// (try to) read all available data from pipe

for (; !pipe_state.eof; ) {

switch (pipe_state.reader.read(intermediate_buffer)) {

case pipe_reader::result::SUCCESS: {

// append to main buffer

pipe_state.buffer.reserve(pipe_state.buffer.size() + intermediate_buffer.size());

std::copy(intermediate_buffer.begin(), intermediate_buffer.end(), std::back_inserter(pipe_state.buffer));

break;

}

case pipe_reader::result::END_OF_FILE: {

pipe_state.eof = true;

break;

}

default:

break;

}

}

}

if (proc.is_running()) {

// reduce load on CPU until EOF

std::this_thread::sleep_for(std::chrono::milliseconds(50));

}

// once all buffers are EOF, we can stop reading

if (std::all_of(buffers.begin(), buffers.end(), [](const PipeState& pipe_state) {

return pipe_state.eof;

})) {

break;

}

}

// make sure contents are null-terminated

buffers[0].buffer.emplace_back('\0');

buffers[1].buffer.emplace_back('\0');

auto exit_code = proc.close();

return subprocess_result{exit_code, buffers[0].buffer, buffers[1].buffer};

}

std::string subprocess::check_output() const {

const auto result = run();

if (result.exit_code() != 0) {

throw std::logic_error{"subprocess failed (exit code " + std::to_string(result.exit_code()) + ")"};

}

return result.stdout_string();

}

}

}