Esempio n. 1
0
File: zmsg.c Progetto: bartuer/bew
void
zmsg_remove (zmsg_t *self, zframe_t *frame)
{
    assert (self);
    self->content_size -= zframe_size (frame);
    zlist_remove (self->frames, frame);
}
Esempio n. 2
0
static void
sub_patch_add (sub_t *self, fmq_patch_t *patch)
{
    //  Skip file creation if client already has identical file
    fmq_patch_digest_set (patch);
    if (fmq_patch_op (patch) == patch_create) {
        char *digest = zhash_lookup (self->cache, fmq_patch_virtual (patch));
        if (digest && strcasecmp (digest, fmq_patch_digest (patch)) == 0)
            return;             //  Just skip patch for this client
    }
    //  Remove any previous patches for the same file
    fmq_patch_t *existing = (fmq_patch_t *) zlist_first (self->client->patches);
    while (existing) {
        if (streq (fmq_patch_virtual (patch), fmq_patch_virtual (existing))) {
            zlist_remove (self->client->patches, existing);
            fmq_patch_destroy (&existing);
            break;
        }
        existing = (fmq_patch_t *) zlist_next (self->client->patches);
    }
    if (fmq_patch_op (patch) == patch_create)
        zhash_insert (self->cache,
            fmq_patch_digest (patch), fmq_patch_virtual (patch));
    //  Track that we've queued patch for client, so we don't do it twice
    zlist_append (self->client->patches, fmq_patch_dup (patch));
}
Esempio n. 3
0
File: broker.c Progetto: tnako/DP
static void s_worker_delete(worker_t *self, int disconnect)
{
    assert (self);
    if (disconnect) {
        s_worker_send (self, MDPW_DISCONNECT, NULL); // ! Расширить до отключение через mmi
	}

    if (self->service) {
        zlist_remove (self->service->waiting, self);
        self->service->workers--;
    }
    
    zlist_remove (self->broker->waiting, self);
    //  This implicitly calls s_worker_destroy
    zhash_delete (self->broker->workers, self->id_string);
}
Esempio n. 4
0
int wait_destroy_msg (waitqueue_t *q, wait_test_msg_f cb, void *arg)
{
    zlist_t *tmp = NULL;
    wait_t *w;
    int rc = -1;
    int count = 0;

    assert (q->magic == WAITQUEUE_MAGIC);

    w = zlist_first (q->q);
    while (w) {
        if (w->hand.msg && cb != NULL && cb (w->hand.msg, arg)) {
            if (!tmp && !(tmp = zlist_new ()))
                oom ();
            if (zlist_append (tmp, w) < 0)
                oom ();
            w->hand.cb = NULL; // prevent wait_runone from restarting handler
            count++;
        }
        w = zlist_next (q->q);
    }
    if (tmp) {
        while ((w = zlist_pop (tmp))) {
            zlist_remove (q->q, w);
            if (--w->usecount == 0)
                wait_destroy (w);
        }
    }
    rc = count;
    zlist_destroy (&tmp);
    return rc;
}
Esempio n. 5
0
static void subprocess_free (struct subprocess *p)
{
    assert (p != NULL);

    if (p->sm)
        zlist_remove (p->sm->processes, (void *) p);
    zhash_destroy (&p->zhash);
    hooks_table_free (p);

    fda_closeall (p->child_fda);

    if (p->argz)
        free (p->argz);
    if (p->envz)
        free (p->envz);
    if (p->cwd)
        free (p->cwd);

    zio_destroy (p->zio_in);
    zio_destroy (p->zio_out);
    zio_destroy (p->zio_err);

    if (p->parentfd != -1)
        close (p->parentfd);
    if (p->childfd != -1)
        close (p->childfd);
    flux_watcher_destroy (p->child_watcher);

    memset (p, 0, sizeof (*p));
    free (p);
}
Esempio n. 6
0
static void
s_engine_handle_buy_request (engine_t *self, zframe_t *price,
        zframe_t *volume, zframe_t *reply_to)
{
    char *price_str = zframe_strdup (price);
    char *volume_str = zframe_strdup (volume);

    order_t *buy_order = s_order_new (self->worker,
            atoi (price_str), atoi (volume_str), reply_to);

    free (price_str);
    free (volume_str);

    while (buy_order->volume) {
      order_t *sell_order = s_engine_match_sell_order (self);
      if (sell_order == NULL || sell_order->price > buy_order->price)
          break;
      int volume = MIN (buy_order->volume, sell_order->volume);
      s_order_update (buy_order, volume);
      s_order_update (sell_order, volume);

      if (sell_order->volume == 0) {
          zlist_remove (self->sell_orders, sell_order);
          s_order_destroy (&sell_order);
      }
    }

    if (buy_order->volume == 0)
        s_order_destroy (&buy_order);
    else
        zlist_append (self->buy_orders, buy_order);
}
Esempio n. 7
0
File: zctx.c Progetto: dnaeon/czmq
void
zctx__socket_destroy (zctx_t *self, void *zocket)
{
    assert (self);
    assert (zocket);
    zsocket_set_linger (zocket, self->linger);
    zmq_close (zocket);
    zlist_remove (self->sockets, zocket);
}
Esempio n. 8
0
static void
s_service_enable_command (service_t *self, const char *command)
{
    char *item = (char *) zlist_first (self->blacklist);
    while (item && !streq (item, command))
        item = (char *) zlist_next (self->blacklist);
    if (item) {
        zlist_remove (self->blacklist, item);
        free (item);
    }
}
Esempio n. 9
0
static void
s_worker_delete(worker_t *self, int disconnect)
{
    assert(self);
    if (disconnect) {
        mdp_msg_t *msg = mdp_msg_new();
        assert(msg);
        mdp_msg_set_id(msg, MDP_MSG_DISCONNECT);
        mdp_msg_set_routing_id(msg, self->address);
        mdp_msg_send(msg, self->broker->router);
    }
    
    if (self->service) {
        zlist_remove(self->service->waiting, self);
        self->service->workers--;
    }
    zlist_remove(self->broker->waiting, self);
    // This implicitly calls s_worker_destroy.
    zhash_delete(self->broker->workers, self->identity);
}
Esempio n. 10
0
static void
s_timer_remove (zloop_t *self, int timer_id)
{
    s_timer_t *timer = (s_timer_t *) zlist_first (self->timers);
    while (timer) {
        if (timer->timer_id == timer_id) {
            zlist_remove (self->timers, timer);
            free (timer);
            break;
        }
        timer = (s_timer_t *) zlist_next (self->timers);
    }
}
Esempio n. 11
0
static void
s_workers_purge (zlist_t *workers)
{
    worker_t *worker = (worker_t *) zlist_first (workers);
    while (worker) {
        if (zclock_time () < worker->expiry)
            break;              //  Worker is alive, we're done here

        zlist_remove (workers, worker);
        s_worker_destroy (&worker);
        worker = (worker_t *) zlist_first (workers);
    }
}
Esempio n. 12
0
static void
s_worker_ready (worker_t *self, zlist_t *workers)
{
    worker_t *worker = (worker_t *) zlist_first (workers);
    while (worker) {
        if (streq (self->identity, worker->identity)) {
            zlist_remove (workers, worker);
            s_worker_destroy (&worker);
            break;
        }
        worker = (worker_t *) zlist_next (workers);
    }
    zlist_append (workers, self);
}
Esempio n. 13
0
//  If message was already on pending list, remove it and return true,
//  else return false.
static int
s_was_pending (clonesrv_t *self, kvmsg_t *kvmsg)
{
    kvmsg_t *held = (kvmsg_t *) zlist_first (self->pending);
    while (held) {
        if (memcmp (kvmsg_uuid (kvmsg),
                    kvmsg_uuid (held), sizeof (uuid_t)) == 0) {
            zlist_remove (self->pending, held);
            return true;
        }
        held = (kvmsg_t *) zlist_next (self->pending);
    }
    return false;
}
Esempio n. 14
0
static void
mount_sub_purge (mount_t *self, client_t *client)
{
    sub_t *sub = (sub_t *) zlist_first (self->subs);
    while (sub) {
        if (sub->client == client) {
            sub_t *next = (sub_t *) zlist_next (self->subs);
            zlist_remove (self->subs, sub);
            sub_destroy (&sub);
            sub = next;
        }
        else
            sub = (sub_t *) zlist_next (self->subs);
    }
}
Esempio n. 15
0
File: broker.c Progetto: tnako/DP
static void s_service_dispatch(service_t *self, zmsg_t *msg)
{
    assert(self);
    if (msg) {                    //  Queue message if any
        zlist_append(self->requests, msg);
	}

    s_broker_purge(self->broker);
    while (zlist_size(self->waiting) && zlist_size(self->requests)) {
        worker_t *worker = zlist_pop(self->waiting);
        zlist_remove(self->broker->waiting, worker);
        zmsg_t *msg = zlist_pop(self->requests);
        s_worker_send(worker, MDPW_REQUEST, msg);
        zmsg_destroy (&msg);
    }
}
Esempio n. 16
0
static void
peering_lower (peering_t *self)
{
    vocket_t *vocket = self->vocket;
    driver_t *driver = self->driver;
    if (driver->verbose)
        zclock_log ("I: (tcp) take down peering to %s", self->address);
    if (self->alive) {
        self->alive = FALSE;
        zlist_remove (vocket->live_peerings, self);
        if (zlist_size (vocket->live_peerings) < vocket->min_peerings) {
            //  Ask reactor to stop monitoring vocket's msgpipe pipe
            zmq_pollitem_t item = { vocket->msgpipe, 0, ZMQ_POLLIN, 0 };
            zloop_poller_end (driver->loop, &item);
        }
    }
}
Esempio n. 17
0
File: vtx_tcp.c Progetto: imatix/vtx
static void
vocket_destroy (vocket_t **self_p)
{
    assert (self_p);
    if (*self_p) {
        vocket_t *self = *self_p;
        driver_t *driver = self->driver;

        if (self->min_peerings == 0) {
            //  Ask reactor to stop monitoring vocket's msgpipe
            zmq_pollitem_t item = { self->msgpipe, 0, ZMQ_POLLIN, 0 };
            zloop_poller_end (driver->loop, &item);
        }

        //  Close message msgpipe socket
        zsocket_destroy (driver->ctx, self->msgpipe);

        //  Destroy all bindings for this vocket
        zhash_destroy (&self->binding_hash);

        //  Destroy all peerings for this vocket
        zhash_destroy (&self->peering_hash);
        zlist_destroy (&self->peering_list);
        zlist_destroy (&self->live_peerings);

        //  Remove vocket from driver list of vockets
        zlist_remove (driver->vockets, self);

#ifdef VOCKET_STATS
        char *type_name [] = {
            "PAIR", "PUB", "SUB", "REQ", "REP",
            "DEALER", "ROUTER", "PULL", "PUSH",
            "XPUB", "XSUB"
        };
        printf ("I: type=%s sent=%d recd=%d outp=%d inp=%d drop=%d\n",
            type_name [self->socktype],
            self->outgoing, self->incoming,
            self->outpiped, self->inpiped,
            self->dropped);
#endif
        free (self->vtxname);
        free (self);
        *self_p = NULL;
    }
}
Esempio n. 18
0
void
zloop_reader_end (zloop_t *self, zsock_t *sock)
{
    assert (self);
    assert (sock);

    s_reader_t *reader = (s_reader_t *) zlist_first (self->readers);
    while (reader) {
        if (reader->sock == sock) {
            zlist_remove (self->readers, reader);
            free (reader);
            self->need_rebuild = true;
        }
        reader = (s_reader_t *) zlist_next (self->readers);
    }
    if (self->verbose)
        zsys_debug ("zloop: cancel %s reader", zsock_type_str (sock));
}
Esempio n. 19
0
int
zpoller_remove (zpoller_t *self, void *reader)
{
    assert (self);
    assert (reader);
    int rc = 0;
#ifdef ZMQ_HAVE_POLLER
    void *socket = zsock_resolve (reader);
    if (socket)
        rc = zmq_poller_remove (self->zmq_poller, socket);
    else
        rc = zmq_poller_remove_fd (self->zmq_poller, *(SOCKET *) reader);
#else
    zlist_remove (self->reader_list, reader);
    self->need_rebuild = true;
#endif
    return rc;
}
Esempio n. 20
0
static void client_write_cb (flux_t h, flux_fd_watcher_t *w, int fd,
                             int revents, void *arg)
{
    client_t *c = arg;

    if (revents & FLUX_POLLERR)
        goto disconnect;
    if (revents & FLUX_POLLOUT) {
        if (client_send_try (c) < 0)
            goto disconnect;
        //flux_log (h, LOG_DEBUG, "send: client ready");
    }
    if (zlist_size (c->outqueue) == 0)
        flux_fd_watcher_stop (h, w);
    return;
disconnect:
    zlist_remove (c->ctx->clients, c);
    client_destroy (c);
}
Esempio n. 21
0
static void
mount_sub_store (mount_t *self, client_t *client, fmq_msg_t *request)
{
    assert (self);
    assert (self->subs);
    
    //  Store subscription along with any previous ones
    //  Coalesce subscriptions that are on same path
    char *path = fmq_msg_path (request);
    sub_t *sub = (sub_t *) zlist_first (self->subs);
    while (sub) {
        if (client == sub->client) {
            //  If old subscription is superset/same as new, ignore new
            if (strncmp (path, sub->path, strlen (sub->path)) == 0)
                return;
            else
            //  If new subscription is superset of old one, remove old
            if (strncmp (sub->path, path, strlen (path)) == 0) {
                zlist_remove (self->subs, sub);
                sub_destroy (&sub);
                sub = (sub_t *) zlist_first (self->subs);
            }
            else
                sub = (sub_t *) zlist_next (self->subs);
        }
        else
            sub = (sub_t *) zlist_next (self->subs);
    }
    //  New subscription for this client, append to our list
    sub = sub_new (client, path, fmq_msg_cache (request));
    zlist_append (self->subs, sub);

    //  If client requested resync, send full mount contents now
    if (fmq_msg_options_number (client->request, "RESYNC", 0) == 1) {
        zlist_t *patches = zdir_resync (self->dir, self->alias);
        while (zlist_size (patches)) {
            zdir_patch_t *patch = (zdir_patch_t *) zlist_pop (patches);
            sub_patch_add (sub, patch);
            zdir_patch_destroy (&patch);
        }
        zlist_destroy (&patches);
    }
}
Esempio n. 22
0
//  The dispatch method sends request to the worker.
static void
s_service_dispatch (service_t *self)
{
    assert (self);

    s_broker_purge (self->broker);
    if (zlist_size (self->waiting) == 0)
        return;

    while (zlist_size (self->requests) > 0) {
        worker_t *worker = (worker_t*)zlist_pop (self->waiting);
        zlist_remove (self->waiting, worker);
        zmsg_t *msg = (zmsg_t*)zlist_pop (self->requests);
        s_worker_send (worker, MDPW_REQUEST, NULL, msg);
        //  Workers are scheduled in the round-robin fashion
        zlist_append (self->waiting, worker);
        zmsg_destroy (&msg);
    }
}
Esempio n. 23
0
File: zctx.c Progetto: kiml/czmq
void
zctx_destroy (zctx_t **self_p)
{
    assert (self_p);
    if (*self_p) {
        zctx_t *self = *self_p;
        while (zlist_size (self->sockets)) {
            void *socket = zlist_first (self->sockets);
            zsockopt_set_linger (socket, self->linger);
            zmq_close (socket);
            zlist_remove (self->sockets, socket);
        }
        zlist_destroy (&self->sockets);
        if (self->main && self->context)
            zmq_term (self->context);
        free (self);
        *self_p = NULL;
    }
}
Esempio n. 24
0
static void
s_service_destroy (void *argument)
{
    service_t *service = (service_t *) argument;
    while (zlist_size (service->requests)) {
        zmsg_t *msg = (zmsg_t*)zlist_pop (service->requests);
        zmsg_destroy (&msg);
    }
    //  Free memory keeping  blacklisted commands.
    char *command = (char *) zlist_first (service->blacklist);
    while (command) {
        zlist_remove (service->blacklist, command);
        free (command);
    }
    zlist_destroy (&service->requests);
    zlist_destroy (&service->waiting);
    zlist_destroy (&service->blacklist);
    free (service->name);
    free (service);
}
Esempio n. 25
0
void
zloop_poller_end (zloop_t *self, zmq_pollitem_t *item)
{
    assert (self);
    assert (item->socket || item->fd);

    s_poller_t *poller = (s_poller_t *) zlist_first (self->pollers);
    while (poller) {
        if ((item->socket && item->socket == poller->item.socket)
        ||  (item->fd     && item->fd     == poller->item.fd)) {
            zlist_remove (self->pollers, poller);
            free (poller);
            self->dirty = true;
        }
        poller = (s_poller_t *) zlist_next (self->pollers);
    }
    if (self->verbose)
        zclock_log ("I: zloop: cancel %s poller (%p, %d)",
            item->socket? zsocket_type_str (item->socket): "FD",
            item->socket, item->fd);
}
Esempio n. 26
0
File: vtx_tcp.c Progetto: imatix/vtx
static void
peering_delete (void *argument)
{
    peering_t *self = (peering_t *) argument;
    vocket_t *vocket = self->vocket;
    driver_t *driver = self->driver;
    if (driver->verbose)
        zclock_log ("I: (tcp) delete peering %s", self->address);

    //* Start transport-specific work
    s_close_handle (self->handle, driver);
    //* End transport-specific work

    vtx_codec_destroy (&self->input);
    vtx_codec_destroy (&self->output);
    peering_lower (self);
    zlist_remove (vocket->peering_list, self);
    zloop_timer_end (driver->loop, self);
    free (self->address);
    free (self);
    vocket->peerings--;
}
Esempio n. 27
0
static void
s_service_dispatch(service_t *self)
{
    while ((zlist_size(self->requests) > 0) &&
           (zlist_size(self->waiting) > 0)) {
        worker_t *worker = (worker_t *) zlist_pop(self->waiting);
        zlist_remove(self->broker->waiting, worker);
        mdp_msg_t *msg = (mdp_msg_t *) zlist_pop(self->requests);
        mdp_msg_t *worker_msg = mdp_msg_new();
        mdp_msg_set_id(worker_msg, MDP_MSG_WORKER_REQUEST);
        mdp_msg_set_routing_id(worker_msg, worker->address);
        zframe_t *address = zframe_dup(mdp_msg_routing_id(msg));
        mdp_msg_set_address(worker_msg, &address);
        zmsg_t *body = mdp_msg_get_body(msg);

        mdp_msg_set_body(worker_msg, &body);

        mdp_msg_send(worker_msg, self->broker->router);
        mdp_msg_destroy(&worker_msg);
        mdp_msg_destroy(&msg);
    }
}
Esempio n. 28
0
int module_unsubscribe (modhash_t *mh, const char *uuid, const char *topic)
{
    module_t *p = zhash_lookup (mh->zh_byuuid, uuid);
    char *s;
    int rc = -1;

    if (!p) {
        errno = ENOENT;
        goto done;
    }
    s = zlist_first (p->subs);
    while (s) {
        if (!strcmp (topic, s)) {
            zlist_remove (p->subs, s);
            break;
        }
        s = zlist_next (p->subs);
    }
    rc = 0;
done:
    return rc;
}
Esempio n. 29
0
void
zloop_poller_end (zloop_t *self, zmq_pollitem_t *item)
{
    assert (self);
    assert (item->socket || item->fd);

    s_poller_t *poller = (s_poller_t *) zlist_first (self->pollers);
    while (poller) {
        if ((item->socket && item->socket == poller->item.socket)
        ||  (item->fd     && item->fd     == poller->item.fd)) {
            zlist_remove (self->pollers, poller);
            free (poller);
            //  Force rebuild to avoid reading from freed poller
            self->need_rebuild = true;
        }
        poller = (s_poller_t *) zlist_next (self->pollers);
    }
    if (self->verbose)
        zsys_debug ("zloop: cancel %s poller (%p, %d)",
            item->socket? zsocket_type_str (item->socket): "FD",
            item->socket, item->fd);
}
Esempio n. 30
0
File: zsys.c Progetto: wysman/czmq
int
zsys_close (void *handle, const char *filename, size_t line_nbr)
{
    ZMUTEX_LOCK (s_mutex);
    //  It's possible atexit() has already happened if we're running under
    //  a debugger that redirects the main thread exit.
    if (filename && s_sockref_list) {
        s_sockref_t *sockref = (s_sockref_t *) zlist_first (s_sockref_list);
        while (sockref) {
            if (sockref->handle == handle) {
                zlist_remove (s_sockref_list, sockref);
                free (sockref);
                break;
            }
            sockref = (s_sockref_t *) zlist_next (s_sockref_list);
        }
    }
    s_open_sockets--;
    zmq_close (handle);
    ZMUTEX_UNLOCK (s_mutex);
    return 0;
}