示例#1
0
bool CZmqWrapper::addDevice(std::string srcstring,std::string dststring)
{
  zmq::socket_t* _pSrcSocket = new zmq::socket_t(m_context,ZMQ_ROUTER);
  if (!_pSrcSocket)
  {
      return false;
  } 

  try
  {                                                                
      _pSrcSocket->bind(srcstring.c_str());
  }
  catch(zmq::error_t err)
  {
	  printf("%s,%d,error %s\n",__FUNCTION__,__LINE__,err.what());
  }

  zmq::socket_t* _pDstSocket = new zmq::socket_t(m_context,ZMQ_DEALER);
  if (!_pDstSocket)
  {
	  return false;
  }

  try
  {
	  _pDstSocket->bind(dststring.c_str());
  }
  catch(zmq::error_t err)
  {
	printf("%s,%d,error %s\n",__FUNCTION__,__LINE__,err.what());
  }

  zmq_device(ZMQ_QUEUE,*_pSrcSocket,*_pDstSocket);
}
示例#2
0
void *glbColl_add_storage(void *arg)
{
    void *context;
    void *frontend;
    void *backend;
    int ret;

    context = zmq_init(1);

    frontend = zmq_socket(context, ZMQ_SUB);
    if (!frontend) pthread_exit(NULL);
    zmq_bind(frontend, "tcp://127.0.0.1:6910");
    zmq_setsockopt(frontend, ZMQ_SUBSCRIBE, "", 0);

    backend = zmq_socket(context, ZMQ_PUB);
    if (!backend) pthread_exit(NULL);
    zmq_bind(backend, "tcp://127.0.0.1:6911");

    printf("    ++ Collection storage device ready....\n");

    zmq_device(ZMQ_FORWARDER, frontend, backend);

    /* we never get here */
    zmq_close(frontend);
    zmq_close(backend);
    zmq_term(context);

    return;
}
示例#3
0
文件: ciao_zmq_ll.c 项目: AtnNn/ciao
void
ciao_zmq_device(char *type_atom, char *frontend, char *backend) {
  
  ciao_zmq_socket_assoc *front_assoc= find_socket(frontend);
  if(front_assoc == NULL) {
    report_error(EINVAL, "socket_not_found", frontend);
    return;
  }

  ciao_zmq_socket_assoc *back_assoc= find_socket(backend);
  if(back_assoc==NULL) {
    report_error(EINVAL, "socket_not_found", backend);
    return;
  }

  ciao_zmq_atom_option *opt= find_option(device_options, type_atom);
  if(opt == NULL) {
    report_error(EINVAL, "invalid_device", type_atom);
    return;
  }

  zmq_device(opt->value, 
	     front_assoc->zmq_socket, 
	     back_assoc->zmq_socket);
}
示例#4
0
/**
 *  glbCollection network service startup
 */
static int 
glbColl_start(struct glbColl *self)
{
    void *context;
    void *frontend;
    void *backend;
    pthread_t storage_outlet;
    int ret;

    ret = pthread_create(&storage_outlet, 
			 NULL, 
			 glbColl_add_storage, (void*)self);

    context = zmq_init(1);

    frontend = zmq_socket(context, ZMQ_PULL);
    backend = zmq_socket(context, ZMQ_PUSH);

    zmq_bind(frontend, "tcp://127.0.0.1:6908");
    zmq_bind(backend, "tcp://127.0.0.1:6909");

    printf("  ++ Collection server is up and running!...\n\n");

    zmq_device(ZMQ_QUEUE, frontend, backend);

    /* we never get here */
    zmq_close(frontend);
    zmq_close(backend);
    zmq_term(context);

    return glb_OK;
}
示例#5
0
文件: mtserver.c 项目: gochist/zguide
int main () {
    s_version_assert (2, 1);
    void *context = zmq_init (1);

    //  Socket to talk to clients
    void *clients = zmq_socket (context, ZMQ_XREP);
    zmq_bind (clients, "tcp://*:5555");

    //  Socket to talk to workers
    void *workers = zmq_socket (context, ZMQ_XREQ);
    zmq_bind (workers, "inproc://workers");

    //  Launch pool of worker threads
    int thread_nbr;
    for (thread_nbr = 0; thread_nbr != 5; thread_nbr++) {
        pthread_t worker;
        pthread_create (&worker, NULL, worker_routine, context);
    }
    //  Connect work threads to client threads via a queue
    zmq_device (ZMQ_QUEUE, clients, workers);

    //  We never get here but clean up anyhow
    zmq_close (clients);
    zmq_close (workers);
    zmq_term (context);
    return 0;
}
示例#6
0
//  Starts an automagical device
//
//  - zqueue acts as broker, binds XREP and XREQ
//  - zforwarder acts as proxy, connects SUB, binds PUB
//  - zstreamer acts as proxy, binds PULL, connects PUSH
//
static void
s_start_automagic_device (char *type, char *frontend, char *backend)
{
    void *context = zmq_init (1);

    int device;                 //  0MQ defined type
    int frontend_type;          //  Socket types depending
    int backend_type;           //    on the device type
    s_parse_device_type (type, &device, &frontend_type, &backend_type);

    //  Create and configure sockets
    void *frontend_socket = zmq_socket (context, frontend_type);
    assert (frontend_socket);
    void *backend_socket = zmq_socket (context, backend_type);
    assert (backend_socket);

    if (device == ZMQ_QUEUE) {
        printf ("I: Binding to %s for client connections\n", frontend);
        if (zmq_bind (frontend_socket, frontend)) {
            printf ("E: cannot bind to '%s': %s\n", frontend, zmq_strerror (errno));
            exit (EXIT_FAILURE);
        }
        printf ("I: Binding to %s for service connections\n", backend);
        if (zmq_bind (backend_socket, backend)) {
            printf ("E: cannot bind to '%s': %s\n", backend, zmq_strerror (errno));
            exit (EXIT_FAILURE);
        }
    }
    else
    if (device == ZMQ_FORWARDER) {
        printf ("I: Connecting to publisher at %s\n", frontend);
        if (zmq_connect (frontend_socket, frontend)) {
            printf ("E: cannot connect to '%s': %s\n", frontend, zmq_strerror (errno));
            exit (EXIT_FAILURE);
        }
        printf ("I: Binding to %s for subscriber connections\n", backend);
        if (zmq_bind (backend_socket, backend)) {
            printf ("E: cannot bind to '%s': %s\n", backend, zmq_strerror (errno));
            exit (EXIT_FAILURE);
        }
    }
    else
    if (device == ZMQ_STREAMER) {
        printf ("I: Binding to %s for upstream nodes\n", frontend);
        if (zmq_bind (frontend_socket, frontend)) {
            printf ("E: cannot bind to '%s': %s\n", frontend, zmq_strerror (errno));
            exit (EXIT_FAILURE);
        }
        printf ("I: Connecting downstream to %s\n", backend);
        if (zmq_connect (backend_socket, backend)) {
            printf ("E: cannot connect to '%s': %s\n", backend, zmq_strerror (errno));
            exit (EXIT_FAILURE);
        }
    }
    zmq_device (device, frontend_socket, backend_socket);
}
示例#7
0
//  Starts a device as configured by a full ZDCF config file
//
static void
s_start_configured_device (char *filename)
{
    FILE *file;                 //  JSON config file stream
    if (streq (filename, "-"))
        file = stdin;           //  "-" means read from stdin
    else {
        file = fopen (filename, "rb");
        if (!file) {
            printf ("E: '%s' doesn't exist or can't be read\n", filename);
            exit (EXIT_FAILURE);
        }
    }
    //  Load config data into blob
    zfl_blob_t *blob = zfl_blob_new ();
    assert (blob);
    zfl_blob_load (blob, file);
    fclose (file);

    //  Create a new config from the blob data
    zfl_config_t *config = zfl_config_new (zfl_blob_data (blob));
    assert (config);

    //  Find first device
    char *device = zfl_config_device (config, 0);
    if (!*device) {
        printf ("E: No device specified, please read http://rfc.zeromq.org/spec:3\n");
        exit (EXIT_FAILURE);
    }
    //  Process device type
    char *type = zfl_config_device_type (config, device);

    int device_type;            //  0MQ defined type
    int frontend_type;          //  Socket types depending
    int backend_type;           //    on the device type
    s_parse_device_type (type, &device_type, &frontend_type, &backend_type);

    //  Create and configure sockets
    void *frontend = zfl_config_socket (config, device, "frontend", frontend_type);
    assert (frontend);
    void *backend = zfl_config_socket (config, device, "backend", backend_type);
    assert (backend);

    //  Start the device now
    if (zfl_config_verbose (config))
        printf ("I: Starting device...\n");

    //  Will not actually ever return
    zmq_device (device_type, frontend, backend);

    zfl_config_destroy (&config);
}
示例#8
0
int main ()
{
    //  Prepare our context and sockets
    zmq::context_t context (1);
    zmq::socket_t servers (context, ZMQ_DEALER);
    servers.bind ("tcp://*:5555");
    zmq::socket_t clients (context, ZMQ_ROUTER);
    clients.bind ("tcp://*:5556");

	zmq_device (ZMQ_FORWARDER, (void *)clients, (void *)servers);

    return 0;
}
示例#9
0
文件: queue.cpp 项目: mattmcd/ZeroMQ
int main (int argc, char *argv[]) 
{
  zmq::context_t context(1);
  zmq::socket_t frontend ( context, ZMQ_ROUTER );
  frontend.bind( "tcp://127.0.0.1:5000");
  
  zmq::socket_t backend ( context, ZMQ_DEALER );
  backend.bind( "tcp://127.0.0.1:5001");

  zmq_device( ZMQ_QUEUE, frontend, backend );

  return 0;
}
示例#10
0
int main ( int argc, char *argv[] )
{
  void *context = zmq_init (1);
  assert(context);

  //  Create frontend and backend sockets
  void *frontend = zmq_socket (context, ZMQ_XREP);
  assert (frontend);
  void *backend = zmq_socket (context, ZMQ_XREQ);
  assert (backend);
  //  Bind both sockets to TCP ports
  assert (zmq_bind (frontend, argv[1]) == 0);
  assert (zmq_bind (backend, argv[2]) == 0);
  /* assert (zmq_bind (frontend, "tcp://\*:4446") == 0); */
  /* assert (zmq_bind (backend, "tcp://\*:13000") == 0); */
  zmq_device (ZMQ_QUEUE, frontend, backend);
}
示例#11
0
int main(int argc, char **argv){
    char addr[32];

    init_options();
    parse_options(argc, argv);

    if (GlobalArgs.helpflag || GlobalArgs.dbname == NULL){
	metadatadb_usage();
	return 0;
    }

    /* init daemon */ 
    init_process();
    
    /* init zeromq */ 
    void *ctx = zmq_init(1);
    if (ctx == NULL){
	syslog(LOG_CRIT,"MAIN ERROR: unable to init zmq context");
	exit(1);
    }

    snprintf(addr, 32, "tcp://*:%d", GlobalArgs.port);
    void *clients_skt = socket_bind(ctx, ZMQ_XREP, addr);
    if (clients_skt == NULL){
	syslog(LOG_CRIT,"MAIN ERROR: unable to bind skt to %s", addr);
	exit(1);
    }

    void *workers_skt = socket_bind(ctx, ZMQ_XREQ, "inproc://pipe");
    if (workers_skt == NULL){
	syslog(LOG_CRIT,"MAIN ERROR: unable to bind workers skt");
	exit(1);
    }

    unsigned int i;
    pthread_t worker_thr;
    for (i=0;i < GlobalArgs.nbthreads;i++){
	assert(pthread_create(&worker_thr, NULL, dowork, ctx) == 0);
    }

    assert(zmq_device(ZMQ_QUEUE, clients_skt, workers_skt) == 0);

    return 0;
}
int main (int argc, char *argv[])
{
    zmq::context_t context(1);

    //  Socket facing clients
    zmq::socket_t frontend (context, ZMQ_ROUTER);
    frontend.bind("tcp://*:5559");

    //  Socket facing services
    zmq::socket_t backend (context, ZMQ_DEALER);
    zmq_bind (static_cast<void *>(backend), "tcp://*:5560");

    //  Start built-in device
    zmq_device (
            ZMQ_QUEUE,
            static_cast<void *>(frontend),
            static_cast<void *>(backend)
            );
    return 0;
}
示例#13
0
int main (void) 
{
    void *context = zmq_init (1);

    //  Socket facing clients
    void *frontend = zmq_socket (context, ZMQ_XREP);
    zmq_bind (frontend, "tcp://*:5559");

    //  Socket facing services
    void *backend = zmq_socket (context, ZMQ_XREQ);
    zmq_bind (backend, "tcp://*:5560");

    //  Start built-in device
    zmq_device (ZMQ_QUEUE, frontend, backend);

    //  We never get here...
    zmq_close (frontend);
    zmq_close (backend);
    zmq_term (context);
    return 0;
}
示例#14
0
//  Starts a device as configured by a JSON or text config file
//
static void
s_start_configured_device (char *filename)
{


    //  Create and configure a zfl_device object
    zfl_device_t *device = zfl_device_new (filename);
    if (!device) {
        printf ("E: '%s' can't be read, or has invalid syntax\n", filename);
        exit (EXIT_FAILURE);
    }
    //  Find first device
    char *main_device = zfl_device_locate (device, 0);
    if (!*main_device) {
        printf ("E: No device specified, please read http://rfc.zeromq.org/spec:5\n");
        exit (EXIT_FAILURE);
    }
    //  Process device type
    char *type = zfl_device_property (device, main_device, "type");

    int device_type;            //  0MQ defined type
    int frontend_type;          //  Socket types depending
    int backend_type;           //    on the device type
    s_parse_device_type (type, &device_type, &frontend_type, &backend_type);

    //  Create and configure sockets
    void *frontend = zfl_device_socket (device, main_device, "frontend", frontend_type);
    assert (frontend);
    void *backend = zfl_device_socket (device, main_device, "backend", backend_type);
    assert (backend);

    //  Start the device now
    if (zfl_device_verbose (device))
        printf ("I: Starting device...\n");

    //  Will not actually ever return
    zmq_device (device_type, frontend, backend);

    zfl_device_destroy (&device);
}
示例#15
0
ZMQ_EXPORT int WINAPI mql4zmq_device (int device, void * insocket, void* outsocket)
{
	return zmq_device(device, insocket, outsocket);
}
示例#16
0
 inline void device (int device_, void * insocket_, void* outsocket_)
 {
     int rc = zmq_device (device_, insocket_, outsocket_);
     if (rc != 0)
         throw error_t ();
 }
示例#17
0
int main(int argc, char** argv)
{
    s_catch_signals();
    std::string configPath(CONFIG);

    if(argc > 1)
    {
        configPath = std::string(argv[1]);
    }

    std::ifstream file;
    std::stringstream ss;

    file.open(configPath.c_str());
    if (file.is_open())
    {
        ss << file.rdbuf();   
        file.close();
    }
    else
    {
        exit(1);
    }

    json::JSONObject config(ss);

    leveldb::Options options;
    options.create_if_missing = true;
    leveldb::DB::Open(options, config.get("StorageDirectory"), &db);

    context = zmq_init(1);
    void *frontend = zmq_socket(context, ZMQ_ROUTER),
         *backend  = zmq_socket(context, ZMQ_DEALER);
    zmq_bind(frontend, config.get("StorageAdd").c_str());
    zmq_bind(backend, "inproc://storageWorkers");

    MessageFactory *msgFactory = new MessageFactory();
    ActionFactory *actionsFactory = new ActionFactory(db);

    nExecutors = config.getInt("StorageNWorkers");
    executors = new Executor*[nExecutors];

    for(size_t i = 0; i < nExecutors; i++)
    {
        executors[i] = new Executor(msgFactory, actionsFactory, context);
        executors[i]->start();
    }    
    zmq_device(ZMQ_QUEUE, frontend, backend);

    for(size_t i = 0; i < nExecutors; i++)
    {
        delete executors[i];
    }

    delete actionsFactory;
    delete msgFactory;
    delete executors;
    zmq_close(frontend);
    zmq_close(backend);
    zmq_term(context);
    return 0;
}
示例#18
0
文件: qzmq.c 项目: jaeheum/qzmq
Z K3(device){TC2(x,-KI,-KJ); IC(x); PC(y); PC(z); R kj(zmq_device(xi, VSK(y), VSK(z)));}
示例#19
0
int main(int argc, char **argv)
{
    if (argc < 2) {
        printf("\n");
        printf("rs_test LIO_COMMON_OPTIONS\n");
        lio_print_options(stdout);
        return(1);
    }

    int thread_nbr;

    lio_init(&argc, &argv);

    thread_nbr = lio_parallel_task_count;

    //*** Parses the args
    char *svr_proto, *svr_addr, *svr_port, *zmq_svr;

    //** Retrieves remote zmq server name, transport protocol, and lisenting port
    svr_proto = inip_get_string(lio_gc->ifd, "zmq_server", "protocol", RS_ZMQ_DFT_PROTO);
    svr_addr = inip_get_string(lio_gc->ifd, "zmq_server", "server", NULL);
    svr_port = inip_get_string(lio_gc->ifd, "zmq_server", "port", RS_ZMQ_DFT_PORT);
    asprintf(&zmq_svr, "%s://%s:%s", string_trim(svr_proto), string_trim(svr_addr), string_trim(svr_port));


    //** Creates zmq context
    void *context = zmq_ctx_new();
    assert(context != NULL);

    //** Creates zmq router and binds it to tcp://*:5555
    //** It talks to rs client
    void *router = zmq_socket(context, ZMQ_ROUTER);
    assert(router != NULL);
    int rc = zmq_bind(router, zmq_svr);
    assert(rc != -1);
    printf("ZMQ router socket created.\n");

    // Creates and binds DEALER socket to inproc://worker
    // It talks to workers
    void *dealer = zmq_socket(context, ZMQ_DEALER);
    assert(dealer != NULL);
    rc = zmq_bind(dealer, "inproc://worker");
    assert(rc != -1);
    printf("ZMQ dealer socket created.\n");

    //** Blocks the SIGINT, SIGTERM signals
    sigemptyset(&signal_mask);
    sigaddset(&signal_mask, SIGINT);
    sigaddset(&signal_mask, SIGTERM);
    rc = pthread_sigmask(SIG_BLOCK, &signal_mask, NULL);
    assert(rc == 0);

    //** Launches thread pool
    printf("Launching threads...\n");
    int thread_count;
    rs_zmq_thread_arg_t **arg;
    type_malloc_clear(arg, rs_zmq_thread_arg_t *, thread_nbr);
    pthread_t *workers;
    type_malloc_clear(workers, pthread_t, thread_nbr);
    for (thread_count = 0; thread_count < thread_nbr; thread_count++) {
        type_malloc_clear(arg[thread_count], rs_zmq_thread_arg_t, 1);
        arg[thread_count]->zmq_context = context;
        arg[thread_count]->rs = lio_gc->rs;
        arg[thread_count]->da = ds_attr_create(lio_gc->ds);
        arg[thread_count]->ds = lio_gc->ds;
        arg[thread_count]->timeout = lio_gc->timeout;
        pthread_create(&workers[thread_count], NULL, rs_zmq_worker_routine, (void *)arg[thread_count]);
    }
    printf("Launched all %d threads.\n", thread_nbr);

    //** Unblocks the SIGINT, SIGTERM signals
    rc = pthread_sigmask(SIG_UNBLOCK, &signal_mask, NULL);
    assert(rc == 0);

    //** Catches the SIGNIT, SIGTERM signals
    catch_signals();

    //** Uses a QUEUE device to connect router and dealer
    zmq_device(ZMQ_QUEUE, router, dealer);

    if (s_interrupted == 1)
        printf("Interrupt received, killing server...\n");

    //** Shutdown zmq should go before cleaning thread resources
    zmq_close(router);
    zmq_close(dealer);
    printf("Destroied ZMQ router and dealer\n");
    zmq_ctx_destroy(context); //** This "trigers" the exit of all threads, because it makes all blocking operations on sockets return
    printf("Destroied ZMQ context\n");
    fflush(stdout);

    //** Waits for all threads to exit
    for (thread_count = 0; thread_count < thread_nbr; thread_count++) {
        pthread_join(workers[thread_count], NULL);
    }

    //** Destroys allocations for threads
    for (thread_count = 0; thread_count < thread_nbr; thread_count++) {
        ds_attr_destroy(lio_gc->ds, arg[thread_count]->da);
        free(arg[thread_count]);
    }
    free(arg);
    free(workers);

    free(svr_proto);
    free(svr_addr);
    free(svr_port);
    free(zmq_svr);

    lio_shutdown();

    return(0);
}