func (_tailer *Tailer) loop() {
	transcript.TraceDebugging("running tailer...")
	var _error error
	var _offset int64
	transcript.TraceDebugging("opening tailer file...")
	_tailer.file, _error = os.Open(_tailer.path)
	if _error != nil {
		transcript.TraceError("error encountered while opening tailer file; aborting...")
		panic(_error)
	}
	defer _tailer.file.Close()
	_offset, _error = _tailer.file.Seek(0, os.SEEK_END)
	if _error != nil {
		transcript.TraceWarning("error encountered while positioning tailer file; ignoring...")
	}
	_tailer.pushIdentifier, _tailer.pushChannel = _tailer.router.CreateInbound()
	defer _tailer.router.UnregisterInbound(_tailer.pushIdentifier)
	_reader := bufio.NewReader(_tailer.file)
	for _counter := 0; ; _counter += 1 {
		_line, _error := _reader.ReadBytes('\n')
		if _error == io.EOF {
			time.Sleep(100 * time.Millisecond)
			continue
		}
		if _error != nil {
			transcript.TraceError("error encountered while reading tailer file; aborting...")
			panic(_error)
		}
		if (_counter == 0) && (_offset != 0) {
			continue
		}
		_tailer.pushChannel <- Event{Payload: _line}
	}
}
func (_publisher *Publisher) loop() {
	transcript.TraceDebugging("running publisher...")
	defer C.pxmq_outbound_channel_destroy(_publisher.backend)
	_publisher.pullChannel = make(chan Event, 1024)
	_publisher.pullIdentifier = _publisher.router.RegisterOutbound(_publisher.pullChannel)
	defer _publisher.router.UnregisterOutbound(_publisher.pullIdentifier)
	for {
		transcript.TraceDebugging("waiting publisher action...")
		_event := <-_publisher.pullChannel
		_outcome := C.pxmq_outbound_channel_push(_publisher.backend, unsafe.Pointer(&_event.Payload[0]), C.size_t(len(_event.Payload)), 0)
		_error := syscall.Errno(_outcome)
		if (_error != 0) && (_error != syscall.EAGAIN) {
			panic(errors.New("backend push failed: " + syscall.Errno(_outcome).Error()))
		}
	}
}
func (_streamer *Streamer) loop() {
	transcript.TraceDebugging("starting http streamer...")
	_error := _streamer.server.ListenAndServe()
	if _error != nil {
		transcript.TraceError("error encountered while starting http streamer: `%s`; aborting...", _error.Error())
		panic(_error)
	}
}
func (_router *router) handleUnregisterInbound(_inputs interface{}) (interface{}, error) {
	_identifier, _ok := _inputs.(channelIdentifier)
	if !_ok || (_identifier == 0) {
		return nil, errors.New("invalid inputs")
	}
	transcript.TraceDebugging("unregistering router inbound channel...")
	delete(_router.inboundChannels, _identifier)
	return nil, nil
}
func (_counter *Counter) loop() {
	transcript.TraceDebugging("running counter...")
	_counter.pushIdentifier, _counter.pushChannel = _counter.router.CreateInbound()
	defer _counter.router.UnregisterInbound(_counter.pushIdentifier)
	for {
		time.Sleep(_counter.interval)
		_counter.counter += 1
		_counter.pushChannel <- Event{Payload: []byte(fmt.Sprintf("%d\n", _counter.counter))}
	}
}
func (_router *router) handleEvent(_event Event) {
	transcript.TraceDebugging("routing event...")
	for _, _channel := range _router.outboundChannels {
		select {
		case _channel <- _event:
		default:
			transcript.TraceWarning("channel buffer overflow...")
		}
	}
}
func (_router *router) handleRegisterOutbound(_inputs interface{}) (interface{}, error) {
	_channel, _ok := _inputs.(OutboundChannel)
	if !_ok || (_channel == nil) {
		return nil, errors.New("invalid inputs")
	}
	transcript.TraceDebugging("registering router outbound channel...")
	_router.channelCounter += 1
	_identifier := _router.channelCounter
	_router.outboundChannels[_identifier] = _channel
	return _identifier, nil
}
func (_router *router) handleCreateInbound(_inputs interface{}) (interface{}, error) {
	if _inputs != nil {
		return nil, errors.New("invalid inputs")
	}
	transcript.TraceDebugging("creating router inbound channel...")
	_router.channelCounter += 1
	_identifier := _router.channelCounter
	_channel := make(chan Event, 1024)
	_router.inboundChannels[_identifier] = _channel
	go _router.pipeEvents(_identifier, _channel)
	return channelOutboundPair{_identifier, _channel}, nil
}
func New() *router {
	transcript.TraceDebugging("creating router...")
	_router := &router{
		operations:       make(chan call),
		events:           make(chan Event),
		inboundChannels:  make(map[channelIdentifier]chan Event, 4),
		outboundChannels: make(map[channelIdentifier]OutboundChannel, 4),
		channelCounter:   0,
	}
	go _router.loop()
	return _router
}
Пример #10
0
func (_looper *Looper) loop() {
	transcript.TraceDebugging("running looper...")
	_looper.pullChannel = make(chan Event, 1024)
	_looper.pullIdentifier = _looper.router.RegisterOutbound(_looper.pullChannel)
	defer _looper.router.UnregisterOutbound(_looper.pullIdentifier)
	_looper.pushIdentifier, _looper.pushChannel = _looper.router.CreateInbound()
	defer _looper.router.UnregisterInbound(_looper.pushIdentifier)
	for {
		_event := <-_looper.pullChannel
		_looper.pushChannel <- _event
	}
}
func (_consumer *Consumer) loop() {
	transcript.TraceDebugging("running consumer...")
	defer C.pxmq_inbound_channel_destroy(_consumer.backend)
	_consumer.pushIdentifier, _consumer.pushChannel = _consumer.router.CreateInbound()
	defer _consumer.router.UnregisterInbound(_consumer.pushIdentifier)
	_buffer := make([]byte, 32*1024)
	_bufferCapacity := C.size_t(cap(_buffer))
	for {
		transcript.TraceDebugging("waiting publisher action...")
		var _bufferSize C.size_t
		_outcome := C.pxmq_inbound_channel_pull(_consumer.backend, unsafe.Pointer(&_buffer[0]), _bufferCapacity, &_bufferSize, 1000)
		_error := syscall.Errno(_outcome)
		if (_error != 0) && (_error != syscall.EAGAIN) {
			panic(errors.New("backend pull failed: " + syscall.Errno(_outcome).Error()))
		}
		if _error == 0 {
			_payload := make([]byte, _bufferSize)
			os.Stdout.Write(_payload)
			copy(_payload, _buffer)
			_consumer.pushChannel <- Event{Payload: _payload}
		}
	}
}
Пример #12
0
func (_router *router) loop() {
	transcript.TraceDebugging("running router...")
	for {
		transcript.TraceDebugging("waiting router action...")
		select {
		case _call := <-_router.operations:
			var _outputs interface{}
			var _error error
			switch _call.operation {
			case createInbound:
				_outputs, _error = _router.handleCreateInbound(_call.inputs)
			case unregisterInbound:
				_outputs, _error = _router.handleUnregisterInbound(_call.inputs)
			case registerOutbound:
				_outputs, _error = _router.handleRegisterOutbound(_call.inputs)
			case unregisterOutbound:
				_outputs, _error = _router.handleUnregisterOutbound(_call.inputs)
			}
			_call.callback <- callOutcome{_outputs, _error}
		case _event := <-_router.events:
			_router.handleEvent(_event)
		}
	}
}
func (_server *Streamer) ServeHTTP(_writer http.ResponseWriter, _request *http.Request) {
	transcript.TraceDebugging("serving stream...")
	_pullChannel := make(chan Event, 1024)
	_pullIdentifier := _server.router.RegisterOutbound(_pullChannel)
	defer _server.router.UnregisterOutbound(_pullIdentifier)
	_headers := _writer.Header()
	_headers.Set("Content-Type", "text/plain")
	_writer.WriteHeader(http.StatusOK)
	for {
		_event := <-_pullChannel
		_, _error := _writer.Write(_event.Payload)
		if _error != nil {
			transcript.TraceError("error encountered while serving stream: `%s`; closing...", _error.Error())
			return
		}
		_writer.(http.Flusher).Flush()
	}
}