From 58f0d15c5da74f7908e57ef60ceb5c3d0a7319e3 Mon Sep 17 00:00:00 2001 From: Karen Arutyunov Date: Mon, 18 Mar 2019 13:19:12 +0300 Subject: Add command running API --- libbutl/command.cxx | 269 ++++++++++++++++++++++++++++++++++++++++++++++++++++ libbutl/command.mxx | 84 ++++++++++++++++ 2 files changed, 353 insertions(+) create mode 100644 libbutl/command.cxx create mode 100644 libbutl/command.mxx (limited to 'libbutl') diff --git a/libbutl/command.cxx b/libbutl/command.cxx new file mode 100644 index 0000000..89d7c68 --- /dev/null +++ b/libbutl/command.cxx @@ -0,0 +1,269 @@ +// file : libbutl/command.cxx -*- C++ -*- +// copyright : Copyright (c) 2014-2019 Code Synthesis Ltd +// license : MIT; see accompanying LICENSE file + +#ifndef __cpp_modules +#include +#endif + +#include + +#ifndef __cpp_lib_modules +#include +#include +#include +#include + +#include // ios::failure +#include +#include // move() +#include // invalid_argument +#endif + +// Other includes. + +#ifdef __cpp_modules +module butl.command; + +// Only imports additional to interface. +#ifdef __clang__ +#ifdef __cpp_lib_modules +import std.core; +import std.io; +#endif +import butl.process; +import butl.optional; +#endif + +import butl.fdstream; +import butl.string_parser; +#else +#include +#include +#endif + +using namespace std; + +namespace butl +{ + process_exit + command_run (const string& cmd_str, + const optional& env, + const optional& substitutions, + char subst, + const function& callback) + { + // Split the command line into the program path, arguments, and redirects, + // removing one level of quoting. + // + // Note: may throw invalid_argument. + // + vector cmd ( + string_parser::parse_quoted (cmd_str, true /* unquote */)); + + auto bad_arg = [] (const string& d) {throw invalid_argument (d);}; + + if (cmd.empty ()) + bad_arg ("no program path specified"); + + // Perform substitutions in a string. Throw invalid_argument for a + // malformed substitution or an unknown variable. + // + auto substitute = [&substitutions, subst, &bad_arg] (string&& s) + { + if (!substitutions) + return move (s); + + string r; + size_t p (0); // Current parsing position. + + for (size_t sp; (sp = s.find (subst, p)) != string::npos; ++p) + { + // Append the source string fraction preceding this substitution. + // + r.append (s, p, sp - p); + + ++sp; // Start of the variable name. + p = s.find (subst, sp); // End of the variable name. + + // Unescape the substitution character (adjacent substitution + // characters). + // + if (p == sp) + { + r += subst; + continue; + } + + // Verify that the variable name is properly terminated and doesn't + // contain whitespaces. + // + if (p == string::npos) + bad_arg (string ("unmatched substitution character '") + subst + + "' in '" + s + "'"); + + string vn (s, sp, p - sp); + + assert (!vn.empty ()); // Otherwise it would be an escape sequence. + + if (vn.find_first_of (" \t") != string::npos) + bad_arg ("whitespace in variable name '" + vn + "'"); + + // Find the variable and append its value or fail if it's unknown. + // + auto i (substitutions->find (vn)); + + if (i == substitutions->end ()) + bad_arg ("unknown variable '" + vn + "'"); + + r += i->second; + } + + // Append the source string tail, following the last substitution, and + // optimizing for the no-substitutions case. + // + if (p == 0) + return move (s); + + r.append (s.begin () + p, s.end ()); + return r; + }; + + // Perform substitutions in the program path. + // + string prog (substitute (move (cmd.front ()))); + + // Sort the remaining command line elements into the arguments and + // redirects, performing the substitutions. Complete relative redirects + // against CWD and use the rightmost redirect. + // + vector args; + + optional redir; + bool redir_append (false); + + const dir_path& cwd (env && env->cwd != nullptr ? *env->cwd : dir_path ()); + + for (auto i (cmd.begin () + 1), e (cmd.end ()); i != e; ++i) + { + string a (move (*i)); + + if (a[0] == '>') // Redirect. + { + redir_append = a[1] == '>'; + + size_t n (redir_append ? 2 : 1); + + if (a.size () != n) // Strip the >/>> prefix. + { + a.erase (0, n); + } + else // Take the space-separated file path from the next element. + { + if (++i == e) + bad_arg ("no stdout redirect file specified"); + + a = move (*i); + } + + try + { + redir = dir_path (substitute (move (a))); + } + catch (const invalid_path& e) + { + bad_arg ("invalid stdout redirect file path '" + e.path + "'"); + } + + if (redir->empty ()) + bad_arg ("empty stdout redirect file path"); + + if (redir->relative () && !cwd.empty ()) + redir = cwd / *redir; + } + else // Argument. + { + args.push_back (substitute (move (a))); + } + } + + // Prepare the process environment. + // + // Note: cwd passed to process_env() may not be a temporary object. + // + process_env pe (prog, cwd, env ? env->vars : nullptr); + + // Open the redirect file descriptor, if specified. + // + // Intercept the exception to make the error description more informative. + // + auto_fd rd; + + if (redir) + try + { + fdopen_mode m (fdopen_mode::out | fdopen_mode::create); + m |= redir_append ? fdopen_mode::at_end : fdopen_mode::truncate; + + rd = fdopen (*redir, m); + } + catch (const ios::failure& e) + { + // @@ For libstdc++ the resulting exception description will be + // something like: + // + // unable to open stdout redirect file ...: No such file or directory + // + // Maybe we should improve our operator<<(ostream,exception) to + // lowercase the first word that follows ": " (code description) for + // exceptions derived from system_error. + // + string msg ("unable to open stdout redirect file '" + redir->string () + + "'"); + + // For old versions of g++ (as of 4.9) ios_base::failure is not derived + // from system_error and so we cannot recover the errno value. Lets use + // EIO in this case. This is a temporary code after all. + // + const system_error* se (dynamic_cast (&e)); + + throw_generic_ios_failure (se != nullptr ? se->code ().value () : EIO, + msg.c_str ()); + } + + // Finally, run the process. + // + // If the callback is specified, then intercept its call, appending the + // stdout redirect to the arguments list, if present. + // + return process_run_callback ( + [&callback, &redir, redir_append] (const char* const args[], size_t n) + { + if (callback) + { + if (redir) + { + vector elems (args, args + n); + string rd ((redir_append ? ">>" : ">") + redir->string ()); + + // Inject the redirect prior to the trailing NULL. + // + assert (n > 0); + + elems.insert (elems.begin () + n - 1, rd.c_str ()); + + callback (elems.data (), elems.size ()); + } + else + { + callback (args, n); + } + } + }, + 0 /* stdin */, + redir ? rd.get () : 1 /* stdout */, + 2 /* stderr */, + pe, + args); + } +} diff --git a/libbutl/command.mxx b/libbutl/command.mxx new file mode 100644 index 0000000..e62a032 --- /dev/null +++ b/libbutl/command.mxx @@ -0,0 +1,84 @@ +// file : libbutl/command.mxx -*- C++ -*- +// copyright : Copyright (c) 2014-2019 Code Synthesis Ltd +// license : MIT; see accompanying LICENSE file + +#ifndef __cpp_modules +#pragma once +#endif + +#ifndef __cpp_lib_modules +#include +#include +#include // size_t +#include +#endif + +// Other includes. + +#ifdef __cpp_modules +export module butl.command; +#ifdef __cpp_lib_modules +import std.core; +#endif +import butl.process; +import butl.optional; +#else +#include +#include +#endif + +#include + +LIBBUTL_MODEXPORT namespace butl +{ + // Run a process, interpreting the command line as whitespace-separated, + // potentially quoted program path, arguments, and redirects. Throw + // std::invalid_argument on the parsing error, ios::failure on the + // underlying OS error, and process_error on the process running error. + // + // The process environment path is unused and must point to the empty + // process path. + // + // Currently only the following stdout redirects are supported: + // + // >file # Overwrite file. + // >>file # Append to file. + // + // In particular, the file descriptor cannot be specified. The file path can + // optionally be separated from '>' by whitespaces. Note that redirects are + // distinguished from arguments by the presence of leading '>' and prior to + // possible substitutions (so the redirect character cannot be the result of + // a substitution; see below). + // + // The relative redirect file paths are completed against the command + // current working directory. Note that if it is altered via the process + // environment, then the new value is used. + // + // The command line elements (program, arguments, etc) may optionally + // contain substitutions - variable names enclosed with the substitution + // symbol ('@' by default) - which are replaced with the corresponding + // variable values to produce the actual command. Variable names must not + // contain whitespaces and an attempt to substitute an unknown or a + // malformed variable is an error. Double substitution character ('@@' by + // default) is an escape sequence. + // + // If the variable map is absent, then '@' has no special meaning and is + // treated as a regular character. + // + // The callback function, if specified, is called prior to running the + // command process with the substituted command elements and including + // redirects which will be in the "canonical" form (single argument without + // space after '>'). The callback can be used, for example, for tracing the + // resulting command line, etc. + // + using command_substitution_map = std::map; + using command_callback = void (const char* const args[], std::size_t n); + + LIBBUTL_SYMEXPORT process_exit + command_run (const std::string& command, + const optional& = nullopt, + const optional& = nullopt, + char subst = '@', + const std::function& = {}); + +} -- cgit v1.1