static int wait_fill_event(struct tb_event *event, struct timeval *timeout)
{
/* ;-) */
#define ENOUGH_DATA_FOR_INPUT_PARSING 128
int result;
char buf[ENOUGH_DATA_FOR_INPUT_PARSING];
fd_set events;
memset(event, 0, sizeof(struct tb_event));
/* try to extract event from input buffer, return on success */
event->type = TB_EVENT_KEY;
if (extract_event(event, &inbuf, inputmode) == 0)
return TB_EVENT_KEY;
/* it looks like input buffer is incomplete, let's try the short path */
size_t r = fread(buf, 1, ENOUGH_DATA_FOR_INPUT_PARSING, in);
if (r > 0) {
if (ringbuffer_free_space(&inbuf) < r)
return -1;
ringbuffer_push(&inbuf, buf, r);
if (extract_event(event, &inbuf, inputmode) == 0)
return TB_EVENT_KEY;
}
/* no stuff in FILE's internal buffer, block in select */
while (1) {
FD_ZERO(&events);
FD_SET(in_fileno, &events);
FD_SET(winch_fds[0], &events);
int maxfd = (winch_fds[0] > in_fileno) ? winch_fds[0] : in_fileno;
result = select(maxfd+1, &events, 0, 0, timeout);
if (!result)
return 0;
if (FD_ISSET(in_fileno, &events)) {
event->type = TB_EVENT_KEY;
size_t r = fread(buf, 1, ENOUGH_DATA_FOR_INPUT_PARSING, in);
if (r == 0)
continue;
/* if there is no free space in input buffer, return error */
if (ringbuffer_free_space(&inbuf) < r)
return -1;
/* fill buffer */
ringbuffer_push(&inbuf, buf, r);
if (extract_event(event, &inbuf, inputmode) == 0)
return TB_EVENT_KEY;
}
if (FD_ISSET(winch_fds[0], &events)) {
event->type = TB_EVENT_RESIZE;
int zzz = 0;
read(winch_fds[0], &zzz, sizeof(int));
buffer_size_change_request = 1;
get_term_size(&event->w, &event->h);
return TB_EVENT_RESIZE;
}
}
}
static int wait_fill_event(struct tb_event *event, struct timeval *timeout)
{
// ;-)
#define ENOUGH_DATA_FOR_PARSING 64
fd_set events;
memset(event, 0, sizeof(struct tb_event));
// try to extract event from input buffer, return on success
event->type = TB_EVENT_KEY;
if (extract_event(event, &input_buffer, inputmode))
return event->type;
// it looks like input buffer is incomplete, let's try the short path,
// but first make sure there is enough space
int n = read_up_to(ENOUGH_DATA_FOR_PARSING);
if (n < 0)
return -1;
if (n > 0 && extract_event(event, &input_buffer, inputmode))
return event->type;
// n == 0, or not enough data, let's go to select
while (1) {
FD_ZERO(&events);
FD_SET(inout, &events);
FD_SET(winch_fds[0], &events);
int maxfd = (winch_fds[0] > inout) ? winch_fds[0] : inout;
int result = select(maxfd+1, &events, 0, 0, timeout);
if (!result)
return 0;
if (FD_ISSET(inout, &events)) {
event->type = TB_EVENT_KEY;
n = read_up_to(ENOUGH_DATA_FOR_PARSING);
if (n < 0)
return -1;
if (n == 0)
continue;
if (extract_event(event, &input_buffer, inputmode))
return event->type;
}
if (FD_ISSET(winch_fds[0], &events)) {
event->type = TB_EVENT_RESIZE;
int zzz = 0;
read(winch_fds[0], &zzz, sizeof(int));
buffer_size_change_request = 1;
get_term_size(&event->w, &event->h);
return TB_EVENT_RESIZE;
}
}
}
int main(int argc, char** argv) {
string input;
string output;
int evt_num = -1;
for(int i=1; i < argc; ++i) {
if ( *argv[i] == '-' ) {
switch(::toupper(*(argv[i]+1))) {
case 'E':
if ( 1 != ::sscanf(argv[i+1],"%d",&evt_num) ) {
::printf("\nERROR: No valid event identifier given.\n\n");
return usage();
}
++i;
break;
case 'O':
if ( i+1 < argc ) output = argv[i+1];
++i;
break;
case 'I':
if ( i+1 < argc ) input = argv[i+1];
++i;
break;
default:
return usage();
}
}
}
if ( input.empty() ) {
::printf("\nERROR: No input file(s) supplied\n\n");
return usage();
}
else if ( output.empty() ) {
::printf("\nERROR: No output file supplied.\n\n");
return usage();
}
else if ( evt_num < 0 ) {
::printf("\nERROR: No valid event identifier given.\n\n");
return usage();
}
gROOT->SetBatch(kTRUE);
if ( extract_event(input.c_str(),output.c_str(),evt_num) != EXTRACT_SUCCESS ) {
printf("\nERROR: Event extraction from file %s failed.\n",input.c_str());
return 1;
}
return 0;
}
static int wait_fill_event(struct tb_event *event, struct timeval *timeout)
{
// ;-)
#define ENOUGH_DATA_FOR_PARSING 64
fd_set events;
memset(event, 0, sizeof(struct tb_event));
// try to extract event from input buffer, return on success
event->type = TB_EVENT_KEY;
if (extract_event(event, &input_buffer, inputmode))
return TB_EVENT_KEY;
// it looks like input buffer is incomplete, let's try the short path,
// but first make sure there is enough space
int prevlen = input_buffer.len;
bytebuffer_resize(&input_buffer, prevlen + ENOUGH_DATA_FOR_PARSING);
ssize_t r = read(inout, input_buffer.buf + prevlen,
ENOUGH_DATA_FOR_PARSING);
if (r < 0) {
// EAGAIN / EWOULDBLOCK shouldn't occur here
assert(errno != EAGAIN && errno != EWOULDBLOCK);
return -1;
} else if (r > 0) {
bytebuffer_resize(&input_buffer, prevlen + r);
if (extract_event(event, &input_buffer, inputmode))
return TB_EVENT_KEY;
} else {
bytebuffer_resize(&input_buffer, prevlen);
}
// r == 0, or not enough data, let's go to select
while (1) {
FD_ZERO(&events);
FD_SET(inout, &events);
FD_SET(winch_fds[0], &events);
int maxfd = (winch_fds[0] > inout) ? winch_fds[0] : inout;
int result = select(maxfd+1, &events, 0, 0, timeout);
if (!result)
return 0;
if (FD_ISSET(inout, &events)) {
event->type = TB_EVENT_KEY;
prevlen = input_buffer.len;
bytebuffer_resize(&input_buffer,
prevlen + ENOUGH_DATA_FOR_PARSING);
r = read(inout, input_buffer.buf + prevlen,
ENOUGH_DATA_FOR_PARSING);
if (r < 0) {
// EAGAIN / EWOULDBLOCK shouldn't occur here
assert(errno != EAGAIN && errno != EWOULDBLOCK);
return -1;
}
assert(r > 0);
bytebuffer_resize(&input_buffer, prevlen + r);
if (extract_event(event, &input_buffer, inputmode))
return TB_EVENT_KEY;
}
if (FD_ISSET(winch_fds[0], &events)) {
event->type = TB_EVENT_RESIZE;
int zzz = 0;
read(winch_fds[0], &zzz, sizeof(int));
buffer_size_change_request = 1;
get_term_size(&event->w, &event->h);
return TB_EVENT_RESIZE;
}
}
}
void
te_update_diff(const char *event, HA_Message *msg)
{
int rc = -1;
const char *op = NULL;
crm_data_t *diff = NULL;
crm_data_t *aborted = NULL;
const char *set_name = NULL;
int diff_add_updates = 0;
int diff_add_epoch = 0;
int diff_add_admin_epoch = 0;
int diff_del_updates = 0;
int diff_del_epoch = 0;
int diff_del_admin_epoch = 0;
if(msg == NULL) {
crm_err("NULL update");
return;
}
ha_msg_value_int(msg, F_CIB_RC, &rc);
op = cl_get_string(msg, F_CIB_OPERATION);
if(rc < cib_ok) {
crm_debug_2("Ignoring failed %s operation: %s",
op, cib_error2string(rc));
return;
}
diff = get_message_xml(msg, F_CIB_UPDATE_RESULT);
cib_diff_version_details(
diff,
&diff_add_admin_epoch, &diff_add_epoch, &diff_add_updates,
&diff_del_admin_epoch, &diff_del_epoch, &diff_del_updates);
crm_debug("Processing diff (%s): %d.%d.%d -> %d.%d.%d", op,
diff_del_admin_epoch,diff_del_epoch,diff_del_updates,
diff_add_admin_epoch,diff_add_epoch,diff_add_updates);
log_cib_diff(LOG_DEBUG_2, diff, op);
set_name = "diff-added";
if(diff != NULL) {
crm_data_t *section = NULL;
crm_data_t *change_set = find_xml_node(diff, set_name, FALSE);
change_set = find_xml_node(change_set, XML_TAG_CIB, FALSE);
if(change_set != NULL) {
crm_debug_2("Checking status changes");
section=get_object_root(XML_CIB_TAG_STATUS,change_set);
}
if(section != NULL) {
extract_event(section);
}
crm_debug_2("Checking change set: %s", set_name);
aborted = need_abort(change_set);
}
set_name = "diff-removed";
if(diff != NULL && aborted == NULL) {
crm_data_t *attrs = NULL;
crm_data_t *status = NULL;
crm_data_t *change_set = find_xml_node(diff, set_name, FALSE);
change_set = find_xml_node(change_set, XML_TAG_CIB, FALSE);
crm_debug_2("Checking change set: %s", set_name);
aborted = need_abort(change_set);
if(aborted == NULL && change_set != NULL) {
status = get_object_root(XML_CIB_TAG_STATUS, change_set);
xml_child_iter_filter(
status, node_state, XML_CIB_TAG_STATE,
attrs = find_xml_node(
node_state, XML_TAG_TRANSIENT_NODEATTRS, FALSE);
if(attrs != NULL) {
crm_info("Aborting on "XML_TAG_TRANSIENT_NODEATTRS" deletions");
abort_transition(INFINITY, tg_restart,
XML_TAG_TRANSIENT_NODEATTRS, attrs);
}
);
