commandodev

from eventlet.pools import Pool
from eventlet.timeout import Timeout

class SocketPool(Pool):
    """A pool of sockets connected to a component

    If a socket times out in use, simply close if before handing it back to the
    pool and it will be discarded and a replacement inserted into the pool."""

    def __init__(self, address, **kwargs):

commandodev

{-
One process starts the master process
Other start do-nothing process
master distributes the work among the other processes
-}

module Main where

import Remote
import Control.Monad

commandodev

module Automata where

import Prelude hiding (map, head, foldl, take)
import qualified Prelude as P
import qualified Data.ByteString as BS
import qualified Data.ByteString.Char8 as C
import Data.ByteString.Internal (c2w)
import qualified Data.Map as M
import Data.List (sort)
import Data.Tuple

commandodev

import eventlet
from eventlet import wsgi
from paste.httpserver import serve
from pyramid.config import Configurator
from pyramid.response import Response
from pyramid.view import view_config
from stargate import WebSocketAwareResource, WebSocketView, is_websocket
import simplejson as json

host = "127.0.0.1"

commandodev

{-# LANGUAGE DeriveDataTypeable #-}
module Main where

{-
Example FRP/zeromq app.

The idea is that messages come into a zeromq socket in the form "id state". The state is of each id is tracked until it's complete.
-}

import Control.Monad

commandodev

class Component(object):

    def _setup_sockets(self):

        pub_address = "tcp://whatever..."
        ext_socket = ctx.socket(zmq.PUB)
        ext_socket.bind(pub_address)
        self.internal_addr = "inproc://my_pub"
        int_socket = ctx.socket(zmq.PULL)
        int_socket.bind(self.internal_addr)

commandodev

from eventlet.pools import Pool

class SocketPool(Pool):
    """A pool of sockets connected to a component

    If a socket times out in use, simply close if before handing it back to the
    pool and it will be discarded and a replacement inserted into the pool.
    """

    def __init__(self, address, **kwargs):

commandodev

zombie = require "zombie"
testCase = require("nodeunit").testCase
_ = require "underscore"


tests =
    setUp: (cb) ->
        zombie.visit "http://localhost:<port>/websocket_page_url/", {debug: false}, (err, browser, stat) ->
            @browser = browser
            # Set sensible timout for initial page set up to be done

commandodev

import eventlet

from datetime import datetime
from eventlet.green import zmq
from eventlet.hubs import use_hub

use_hub('zeromq')

def transmit():
    context = zmq.Context()

commandodev

#include <string>
#include <strings.h>
#include <stdint.h>

std::string hexDump( const zmq::message_t & aMessage, num = 0 ) {
  // I'm going to build a hex/ascii dump like you've seen so many times before
  std::string  msg;
  std::string  ascii;
  // get the pointer to the start of the message's payload - and it's size
  const char *buff = (const char *)aMessage.data();