/**
* cockpit_stream_write:
* @self: the pipe
* @data: the data to write
*
* Write @data to the pipe. This is not done immediately, it's
* queued and written when the pipe is ready.
*
* If you cockpit_stream_close() with a @problem, then queued data
* will be discarded.
*
* Calling this function on a closed or closing pipe (one on which
* cockpit_stream_close() has been called) is invalid.
*
* Zero length data blocks are ignored, it doesn't makes sense to
* write zero bytes to a pipe.
*/
void
cockpit_stream_write (CockpitStream *self,
GBytes *data)
{
g_return_if_fail (COCKPIT_IS_STREAM (self));
g_return_if_fail (!self->priv->closing);
g_return_if_fail (!self->priv->closed);
if (g_bytes_get_size (data) == 0)
{
g_debug ("%s: ignoring zero byte data block", self->priv->name);
return;
}
g_queue_push_tail (self->priv->out_queue, g_bytes_ref (data));
if (!self->priv->out_source && !self->priv->out_closed)
{
start_output (self);
}
/*
* If this becomes thread-safe, then something like this is needed:
* g_main_context_wakeup (g_source_get_context (self->priv->source));
*/
}
static void
initialize_io (CockpitStream *self)
{
GInputStream *is;
GOutputStream *os;
g_return_if_fail (self->priv->in_source == NULL);
is = g_io_stream_get_input_stream (self->priv->io);
os = g_io_stream_get_output_stream (self->priv->io);
if (!G_IS_POLLABLE_INPUT_STREAM (is) ||
!g_pollable_input_stream_can_poll (G_POLLABLE_INPUT_STREAM (is)) ||
!G_IS_POLLABLE_OUTPUT_STREAM (os) ||
!g_pollable_output_stream_can_poll (G_POLLABLE_OUTPUT_STREAM (os)))
{
g_warning ("%s: stream is not pollable", self->priv->name);
close_immediately (self, "internal-error");
return;
}
if (self->priv->connecting)
{
g_object_unref (self->priv->connecting);
self->priv->connecting = NULL;
}
self->priv->in_source = g_pollable_input_stream_create_source (G_POLLABLE_INPUT_STREAM (is), NULL);
g_source_set_name (self->priv->in_source, "stream-input");
g_source_set_callback (self->priv->in_source, (GSourceFunc)dispatch_input, self, NULL);
g_source_attach (self->priv->in_source, self->priv->context);
start_output (self);
}
void director::on_config_nudge (base::conf_node& node)
{
string out;
m_info.sample_rate = node.child ("sample_rate").get<int> ();
m_info.block_size = node.child ("block_size").get<int> ();
m_info.num_channels = node.child ("num_channels").get<int> ();
node.child ("output").get (out);
m_world->set_info (m_info);
stop_output ();
start_output ();
}
static void
initialize_io (CockpitStream *self)
{
GInputStream *is;
GOutputStream *os;
g_return_if_fail (self->priv->in_source == NULL);
is = g_io_stream_get_input_stream (self->priv->io);
os = g_io_stream_get_output_stream (self->priv->io);
if (!G_IS_POLLABLE_INPUT_STREAM (is) ||
!g_pollable_input_stream_can_poll (G_POLLABLE_INPUT_STREAM (is)) ||
!G_IS_POLLABLE_OUTPUT_STREAM (os) ||
!g_pollable_output_stream_can_poll (G_POLLABLE_OUTPUT_STREAM (os)))
{
g_warning ("%s: stream is not pollable", self->priv->name);
close_immediately (self, "internal-error");
return;
}
if (self->priv->connecting)
{
cockpit_connectable_unref (self->priv->connecting);
self->priv->connecting = NULL;
}
self->priv->in_source = g_pollable_input_stream_create_source (G_POLLABLE_INPUT_STREAM (is), NULL);
g_source_set_name (self->priv->in_source, "stream-input");
g_source_set_callback (self->priv->in_source, (GSourceFunc)dispatch_input, self, NULL);
g_source_attach (self->priv->in_source, self->priv->context);
if (G_IS_TLS_CONNECTION (self->priv->io))
{
self->priv->sig_accept_cert = g_signal_connect (G_TLS_CONNECTION (self->priv->io),
"accept-certificate",
G_CALLBACK (on_rejected_certificate),
self);
}
else
{
self->priv->sig_accept_cert = 0;
}
start_output (self);
g_signal_emit (self, cockpit_stream_sig_open, 0);
}
/**
* @fn int search(const char *pattern, const char *root, const char *cwd, const char *dbpath, int db)
*
* search: search specified function
*
* @param[in] pattern search pattern
* @param[in] root root of source tree
* @param[in] cwd current directory
* @param[in] dbpath database directory
* @param[in] db #GTAGS,#GRTAGS,#GSYMS
* @return count of output lines
*/
int
search(const char *pattern, const char *root, const char *cwd, const char *dbpath, int db)
{
CONVERT *cv;
int count = 0;
GTOP *gtop;
GTP *gtp;
int flags = 0;
start_output();
/*
* open tag file.
*/
gtop = gtags_open(dbpath, root, db, GTAGS_READ, debug ? GTAGS_DEBUG : 0);
cv = convert_open(type, format, root, cwd, dbpath, stdout, db);
/*
* search through tag file.
*/
if (nofilter & SORT_FILTER)
flags |= GTOP_NOSORT;
if (Gflag)
flags |= GTOP_BASICREGEX;
if (format == FORMAT_PATH)
flags |= GTOP_PATH;
if (iflag)
flags |= GTOP_IGNORECASE;
for (gtp = gtags_first(gtop, pattern, flags); gtp; gtp = gtags_next(gtop)) {
if (Sflag && !locatestring(gtp->path, localprefix, MATCH_AT_FIRST))
continue;
count += output_with_formatting(cv, gtp, gtop->format);
}
convert_close(cv);
if (debug)
gtags_show_statistics(gtop);
gtags_close(gtop);
end_output();
return count;
}
void director::start (base::conf_node& conf, const boost::filesystem::path& home_path)
{
m_config = &conf;
m_filemgr.start (conf.child ("file_manager"), home_path);
for (auto i = m_outdir.begin(); i != m_outdir.end(); ++i)
{
std::unique_ptr<output_director> od (i->second->create_output_director());
od->defaults(m_config->child (i->first));
}
register_config();
m_info.sample_rate = conf.child ("sample_rate").get<int> ();
m_info.num_channels = conf.child ("num_channels").get<int> ();
m_info.block_size = conf.child ("block_size").get<int> ();
m_world = new world (m_info);
m_world->set_patcher (base::manage (new patcher_dynamic));
start_output ();
}
static void
cockpit_pipe_constructed (GObject *object)
{
CockpitPipe *self = COCKPIT_PIPE (object);
GError *error = NULL;
G_OBJECT_CLASS (cockpit_pipe_parent_class)->constructed (object);
if (self->priv->in_fd >= 0)
{
if (!g_unix_set_fd_nonblocking (self->priv->in_fd, TRUE, &error))
{
g_warning ("%s: couldn't set file descriptor to non-blocking: %s",
self->priv->name, error->message);
g_clear_error (&error);
}
self->priv->in_source = cockpit_unix_fd_source_new (self->priv->in_fd, G_IO_IN);
g_source_set_name (self->priv->in_source, "pipe-input");
g_source_set_callback (self->priv->in_source, (GSourceFunc)dispatch_input, self, NULL);
g_source_attach (self->priv->in_source, self->priv->context);
}
if (self->priv->out_fd >= 0)
{
if (!g_unix_set_fd_nonblocking (self->priv->out_fd, TRUE, &error))
{
g_warning ("%s: couldn't set file descriptor to non-blocking: %s",
self->priv->name, error->message);
g_clear_error (&error);
}
start_output (self);
}
if (self->priv->err_fd >= 0)
{
if (!g_unix_set_fd_nonblocking (self->priv->err_fd, TRUE, &error))
{
g_warning ("%s: couldn't set file descriptor to non-blocking: %s",
self->priv->name, error->message);
g_clear_error (&error);
}
self->priv->err_buffer = g_byte_array_new ();
self->priv->err_source = cockpit_unix_fd_source_new (self->priv->err_fd, G_IO_IN);
g_source_set_name (self->priv->err_source, "pipe-error");
g_source_set_callback (self->priv->err_source, (GSourceFunc)dispatch_error, self, NULL);
g_source_attach (self->priv->err_source, self->priv->context);
}
if (self->priv->pid)
{
self->priv->is_process = TRUE;
/* We may need this watch to outlast this process ... */
self->priv->watch_arg = g_new0 (CockpitPipe *, 1);
*(self->priv->watch_arg) = self;
self->priv->child = g_child_watch_source_new (self->priv->pid);
g_source_set_callback (self->priv->child, (GSourceFunc)on_child_reap,
self->priv->watch_arg, g_free);
g_source_attach (self->priv->child, self->priv->context);
}
