void add_options(boost::program_options::options_description& od, option_validator& opt_validator)
{
standard_options(od, opt_validator)
("log-level,l", boost::program_options::value<std::string>(&m_log_level)->default_value("info"), "default shell log level")
("logging-config", boost::program_options::value<std::string>(&m_log_config), "logging configuration file", validator::file(m_log_config))
;
}
static int fetch_with_fetch(struct transport *transport,
int nr_heads, const struct ref **to_fetch)
{
struct helper_data *data = transport->data;
int i;
struct strbuf buf = STRBUF_INIT;
standard_options(transport);
for (i = 0; i < nr_heads; i++) {
const struct ref *posn = to_fetch[i];
if (posn->status & REF_STATUS_UPTODATE)
continue;
strbuf_addf(&buf, "fetch %s %s\n",
sha1_to_hex(posn->old_sha1), posn->name);
}
strbuf_addch(&buf, '\n');
if (write_in_full(data->helper->in, buf.buf, buf.len) != buf.len)
die_errno("cannot send fetch to %s", data->name);
while (1) {
strbuf_reset(&buf);
if (strbuf_getline(&buf, data->out, '\n') == EOF)
exit(128); /* child died, message supplied already */
if (!prefixcmp(buf.buf, "lock ")) {
const char *name = buf.buf + 5;
if (transport->pack_lockfile)
warning("%s also locked %s", data->name, name);
else
transport->pack_lockfile = xstrdup(name);
}
else if (!buf.len)
break;
else
warning("%s unexpectedly said: '%s'", data->name, buf.buf);
}
strbuf_release(&buf);
return 0;
}
/**
* \brief Set up and process command line options.
*/
void process_cmdline_options(boost::program_options::options_description& cmdline_options, option_validator& opt_validator, int argc, char **argv)
{
add_options(cmdline_options);
add_options(cmdline_options, opt_validator);
standard_options(cmdline_options, opt_validator)
.port("shell-port", "remote shell port when daemonised", m_shell_port)
("pidfile", boost::program_options::value<std::string>(&m_pidfile), "pidfile location")
("noerr,n", "shut up stderr (for thrift)")
("help,h", "output help message and exit")
("version", "output service version and exit")
("daemon", "daemonise (fork to background)")
;
m_ownership.add_options(cmdline_options, opt_validator);
m_logging.add_options(cmdline_options, opt_validator);
boost::program_options::store(boost::program_options::parse_command_line(argc, argv, cmdline_options), m_opt_varmap);
boost::program_options::notify(m_opt_varmap);
m_options_valid = true;
}
static int fetch_with_fetch(struct transport *transport,
int nr_heads, struct ref **to_fetch)
{
struct helper_data *data = transport->data;
int i;
struct strbuf buf = STRBUF_INIT;
standard_options(transport);
for (i = 0; i < nr_heads; i++) {
const struct ref *posn = to_fetch[i];
if (posn->status & REF_STATUS_UPTODATE)
continue;
strbuf_addf(&buf, "fetch %s %s\n",
sha1_to_hex(posn->old_sha1), posn->name);
}
strbuf_addch(&buf, '\n');
sendline(data, &buf);
while (1) {
recvline(data, &buf);
if (!prefixcmp(buf.buf, "lock ")) {
const char *name = buf.buf + 5;
if (transport->pack_lockfile)
warning("%s also locked %s", data->name, name);
else
transport->pack_lockfile = xstrdup(name);
}
else if (!buf.len)
break;
else
warning("%s unexpectedly said: '%s'", data->name, buf.buf);
}
strbuf_release(&buf);
return 0;
}
static int
options(pmOptions *opts, char *buffer, size_t length)
{
char *start, *finish, *token;
pmLongOptions option = { 0 };
/*
* Two cases to deal with here - a "standard" option e.g. --host
* which is presented as a single word (no description) OR a full
* description of a command line option, in one of these forms:
*
* --label dump the archive label
* --background=COLOR render background with given color
* -d, --desc get and print metric description
* -b=N, --batch=N fetch N metrics at a time
* -L use a local context connection
* -X=N offset resulting values by N units
*/
if (pmDebug & DBG_TRACE_DESPERATE)
fprintf(stderr, "%s: parsing option: '%s'", pmProgname, buffer);
start = skip_whitespace(skip_nonwhitespace(buffer));
finish = skip_nonwhitespace(start);
if (start[0] != '-') {
*finish = '\0';
return append_text(opts, buffer, length);
}
token = skip_whitespace(finish);
*finish = '\0';
/* if a single word, this is the standard PCP option case - find it */
if (!token || *token == '\0')
return standard_options(opts, start);
/* handle the first two example cases above -- long option only */
if (start[1] == '-') {
token = seek_character(start, '=');
if (*token == '=') {
*token = '\0'; /* e.g. --background=COLOR render ... */
token++;
finish = skip_nonwhitespace(token);
*finish = '\0';
if ((option.argname = strdup(token)) == NULL)
__pmNoMem("argname", strlen(token), PM_FATAL_ERR);
option.has_arg = 1;
} /* else e.g. --label dump the archive label */
if ((option.long_opt = strdup(start + 2)) == NULL)
__pmNoMem("longopt", strlen(start), PM_FATAL_ERR);
token = skip_whitespace(finish + 1);
if ((option.message = strdup(token)) == NULL)
__pmNoMem("message", strlen(token), PM_FATAL_ERR);
return append_option(opts, &option);
}
/* handle next two example cases above -- both long and short options */
token = seek_character(start, ',');
if (*token == ',') {
/* e.g. -b=N, --batch=N fetch N metrics at a time */
option.short_opt = (int)start[1];
/* move onto extracting --batch, [=N], and "fetch..." */
token++; /* move past the comma */
if (*token == '\0' && token - buffer < length) /* move past a null */
token++;
token = skip_whitespace(token);
if ((token = seek_character(token, '-')) == NULL ||
(token - buffer >= length) || (token[1] != '-')) {
fprintf(stderr, "%s: expected long option at \"%s\", line %d ignored\n",
pmProgname, token, lineno);
return -EINVAL;
}
start = token + 2; /* skip double-dash */
if ((token = seek_character(start, '=')) != NULL && *token == '=') {
*token++ = '\0';
option.has_arg = 1; /* now extract the argument name */
finish = skip_nonwhitespace(token);
*finish = '\0';
if ((option.argname = strdup(token)) == NULL)
__pmNoMem("argname", strlen(token), PM_FATAL_ERR);
} else {
finish = skip_nonwhitespace(start);
*finish = '\0';
}
if ((option.long_opt = strdup(start)) == NULL)
__pmNoMem("longopt", strlen(start), PM_FATAL_ERR);
start = skip_whitespace(finish + 1);
if ((option.message = strdup(start)) == NULL)
__pmNoMem("message", strlen(start), PM_FATAL_ERR);
return append_option(opts, &option);
}
/* handle final two example cases above -- short options only */
if (isspace(start[1])) {
fprintf(stderr, "%s: expected short option at \"%s\", line %d ignored\n",
pmProgname, start, lineno);
return -EINVAL;
}
option.long_opt = "";
option.short_opt = start[1];
if ((token = seek_character(start, '=')) != NULL && *token == '=') {
*token++ = '\0';
option.has_arg = 1; /* now extract the argument name */
finish = skip_nonwhitespace(token);
*finish = '\0';
if ((option.argname = strdup(token)) == NULL)
__pmNoMem("argname", strlen(token), PM_FATAL_ERR);
/* e.g. -X=N offset resulting values by N units */
start = skip_whitespace(finish + 2);
} else {
/* e.g. -L use a local context connection */
start = skip_whitespace(start + 3);
}
if ((option.message = strdup(start)) == NULL)
__pmNoMem("message", strlen(start), PM_FATAL_ERR);
return append_option(opts, &option);
}
static int push_refs(struct transport *transport,
struct ref *remote_refs, int flags)
{
int force_all = flags & TRANSPORT_PUSH_FORCE;
int mirror = flags & TRANSPORT_PUSH_MIRROR;
struct helper_data *data = transport->data;
struct strbuf buf = STRBUF_INIT;
struct child_process *helper;
struct ref *ref;
if (!remote_refs)
return 0;
helper = get_helper(transport);
if (!data->push)
return 1;
for (ref = remote_refs; ref; ref = ref->next) {
if (ref->peer_ref)
hashcpy(ref->new_sha1, ref->peer_ref->new_sha1);
else if (!mirror)
continue;
ref->deletion = is_null_sha1(ref->new_sha1);
if (!ref->deletion &&
!hashcmp(ref->old_sha1, ref->new_sha1)) {
ref->status = REF_STATUS_UPTODATE;
continue;
}
if (force_all)
ref->force = 1;
strbuf_addstr(&buf, "push ");
if (!ref->deletion) {
if (ref->force)
strbuf_addch(&buf, '+');
if (ref->peer_ref)
strbuf_addstr(&buf, ref->peer_ref->name);
else
strbuf_addstr(&buf, sha1_to_hex(ref->new_sha1));
}
strbuf_addch(&buf, ':');
strbuf_addstr(&buf, ref->name);
strbuf_addch(&buf, '\n');
}
if (buf.len == 0)
return 0;
transport->verbose = flags & TRANSPORT_PUSH_VERBOSE ? 1 : 0;
standard_options(transport);
if (flags & TRANSPORT_PUSH_DRY_RUN) {
if (set_helper_option(transport, "dry-run", "true") != 0)
die("helper %s does not support dry-run", data->name);
}
strbuf_addch(&buf, '\n');
if (write_in_full(helper->in, buf.buf, buf.len) != buf.len)
exit(128);
ref = remote_refs;
while (1) {
char *refname, *msg;
int status;
strbuf_reset(&buf);
if (strbuf_getline(&buf, data->out, '\n') == EOF)
exit(128); /* child died, message supplied already */
if (!buf.len)
break;
if (!prefixcmp(buf.buf, "ok ")) {
status = REF_STATUS_OK;
refname = buf.buf + 3;
} else if (!prefixcmp(buf.buf, "error ")) {
status = REF_STATUS_REMOTE_REJECT;
refname = buf.buf + 6;
} else
die("expected ok/error, helper said '%s'\n", buf.buf);
msg = strchr(refname, ' ');
if (msg) {
struct strbuf msg_buf = STRBUF_INIT;
const char *end;
*msg++ = '\0';
if (!unquote_c_style(&msg_buf, msg, &end))
msg = strbuf_detach(&msg_buf, NULL);
else
msg = xstrdup(msg);
strbuf_release(&msg_buf);
if (!strcmp(msg, "no match")) {
status = REF_STATUS_NONE;
free(msg);
msg = NULL;
}
else if (!strcmp(msg, "up to date")) {
status = REF_STATUS_UPTODATE;
free(msg);
msg = NULL;
}
else if (!strcmp(msg, "non-fast forward")) {
status = REF_STATUS_REJECT_NONFASTFORWARD;
free(msg);
msg = NULL;
}
}
if (ref)
ref = find_ref_by_name(ref, refname);
if (!ref)
ref = find_ref_by_name(remote_refs, refname);
if (!ref) {
warning("helper reported unexpected status of %s", refname);
continue;
}
ref->status = status;
ref->remote_status = msg;
}
strbuf_release(&buf);
return 0;
}
