TCP

A Ruby StatsD client (https://github.com/etsy/statsd)

Reassemble TCP fragment data from pcap file like Wireshark.

Simple Ruby client library for pachube TCP streaming API. Uses EventMachine for connection handling.JSON format only.

gbip is a small library to interact with the globalbooksinprint.com API. The API is based on raw TCP sockets, none of this fancy HTTP stuff.

TCP driver to read and write events to Event Store

A BinData-powered intercepting proxy for arbitrary TCP streams

A monitoring tool for TCP connections

A service for monitoring MySQL and exposing its health through an HTTP interface for use with TCP load balancers (like haproxy) that support out-of-band health checks using HTTP.

Ship logs from files to a remote syslog server over TCP

A script that waits for a TCP socket to be available at a given address

This implementation of STOMP is aimed at environments where a network connection, such as a WebSocket or TCP socket, is created and then raw data from that connection is passed to/from the STOMP client or server messaging layer provided by this gem.

TCP-socket сервер и клиент для платформы "1С:Предприятие"

Fluentd output plugin for remote syslog

Simple Client and Server app to setup and control remote machines. Uses TCP sockets for comm and Sqlite3 for logging. Currently for intranet use due to minimum security features.

Guard / Listen TCP server to publish filesystem events to guests.

Seamlessly route all TCP traffic for you application through a SOCKS v4 or v5 server with nearly zero effort. Once required and configured all traffic leveraging the TCPSocket class will route via your configured SOCKS server.

Based on Kali Donovan's APN sender 1.x. 2.0 keep things lean - we removed the resque layer, and make APN connection pluggable to multithreaded background worker (like SideKiq) to send Apple Push Notifications over a persistent TCP socket.

SSL Transport Agent is a foundation for all applications that may be classified as Transport Agents (TA). A TA listens to one or more TCP ports and when a connection is made to a listening port, a process is dispatched to communicate with that connection. The most common examples of this type of application are Mail Transport Agents (commonly known as Mail Servers), HTTPS Server (commonly known as a Web Server), Mail Delivery Agents (DOVECOT, for example), and other applications that exchange data through the internet. This gem only handles the interface to the network. The application which will process the data (yours) sits on top of this layer. This gem can operate in plain text or encrypted mode, and provides methods for issuing queries to MySQL and DNS. At the time of this writing, it contains only an AUTH PLAIN authentication method. The test application is a full, multi-port, multi-process SMTP receiver with TLS encryption and PLAIN authentication which demonstrates how the SSL Transport Agent is used. This gem is also an excellent demonstration of how to make SSLSockets work, for those interested in such things. This gem (C) 2015 Michael J. Welch, Ph.D. <mjwelchphd@gmail.com> Source code and documentation can be found on GitHub: https://github.com/mjwelchphd/ssltransportagent

This input plugin allows you to collect incoming events over UDP instead of TCP

TCP Server for JRuby is a tcp server which supports a demo echo server application.

Parallel TCP Server library. This is easy to make Multi-Process / Multi-Thread server

gbip is a small library to interact with the globalbooksinprint.com API. The API is based on raw TCP sockets.

Simple 2d online multiplayer stick figure battle game using the gosu (SDL2 based) gem for client side graphics. The network protocol is tcp based and only using ASCII printable characters.

Legs is a really simple fun networking library that uses 'json-rpc' formated messages over a tcp connection to really easily built peery or server-clienty sorts of apps, for ruby newbies and hackers to build fun little things.

Simple command-line server monitoring with a range of protocols: ICMP, TCP, UDP, HTTP/S, LDAP/S

capybara-webkit-remote allows the capybara driver to point to a browser that's running in a remote host using the TCP socket protocol that capybara-webkit already uses.

Message sender that sends directly to a remote syslog endpoint (Support UDP, TCP, TCP+TLS)

Gem for testing above the fold render on the first tcp round trip.

# holepunch [](http://badge.fury.io/rb/holepunch) [](https://travis-ci.org/undeadlabs/holepunch) Holepunch manages AWS EC2 security groups in a declarative way through a DSL. ## Requirements - Ruby 1.9.3 or newer. ## Installation ```bash gem install holepunch ``` or in your Gemfile ```ruby gem 'holepunch' ``` ## Basic Configuration You need to provide your AWS security credentials and a region. These can be provided via the command-line options, or you can use the standard AWS environment variables: ```bash export AWS_ACCESS_KEY_ID='...' export AWS_SECRET_ACCESS_KEY='...' export AWS_REGION='us-west-2' ``` ## The SecurityGroups file Specify your security groups in a `SecurityGroups` file in your project's root. Declare security groups that you need and the ingresses you want to expose. You can add ingresses using `tcp`, `udp`, and `ping`. For each ingress you can list allowed hosts using group names or CIDR notation. ```ruby group 'web' do desc 'Web servers' tcp 80 end group 'db' do desc 'database servers' tcp 5432, 'web' end group 'log' do desc 'log server' tcp 9999, 'web', 'db', '10.1.0.0/16' end ``` An environment can be specified which is available through the `env` variable. This allows you to have custom security groups per server environment. ```ruby group "#{env}-web" group "#{env}-db" do tcp 5432, "#{env}-web" end ``` Your application may depend on security groups defined by other services. Ensure they exist using the `depends` method. ```ruby depends 'my-other-service' group 'my-service' do udp 9999, 'my-other-service' end ``` You may specify port ranges for `tcp` and `udp` using the range operator. ```ruby group 'my-service' do udp 5000..9999, '0.0.0.0/0' end ``` You can specify ping/icmp rules with `icmp` (alias: `ping`). ```ruby group 'my-service' do ping '10.0.0.0/16' end ``` It can be useful to describe groups of security groups you plan to launch instances with by using the `service` declaration. ```ruby service "#{env}-web" do groups %W( admin #{env}-log-producer #{env}-web ) end ``` ## Usage Simply navigate to the directory containing your `SecurityGroups` file and run `holepunch`. ``` $ holepunch ``` If you need to specify an environment: ``` $ holepunch -e live ``` You can get a list of security groups for a service using the `service` subcommand. ``` $ holepunch service -e prod prod-web admin,prod-log-producer,prod-web ``` You can also get a list of all defined services. ``` $ holepunch service --list ``` ## Testing You can run the unit tests by simply running rspec. ``` $ rspec ``` By default the integration tests with EC2 are not run. You may run them with: ``` $ rspec -t integration ``` ## Authors - Ben Scott (gamepoet@gmail.com) - Pat Wyatt (pat@codeofhonor.com) ## License Copyright 2014 Undead Labs, LLC. Licensed under the MIT License: http://opensource.org/licenses/MIT

loomsystems output plugin for Fluentd - enabling the transfer of fluentd events trough a secured ssl tcp connection

This simple library implements HTCP protocol (www.htcp.org/) and could be used in any Ruby project to manage any HTCP-compliant caching server (authors use it for Squid 2.7 servers management).

Binary allowing the communication with a MINE server. It support both MINE Protocol over TCP and over WebSocket.

Capp is a packet capture library that wraps libpcap. Capp provides a simple API for capturing packets and automatically unpacks common packets (including Ethernet, IP, TCP, UDP and ICMP). Capp also cooperates with other threads better than other pcap wrapper libraries for ruby.

Simple library to open/accept TCP connections and send/receive messages of strings over the connection.

A network server for distributing computations across different clients speaking TCP or UDP.

Simple tool for creating advanced tcpdump queries, because manually writing `tcp[((tcp[12:1] & 0xf0) >> 2):4] = 0x47455420` is no fun.

A DSL for programming little Tcp client and server

Smuggle TCP connections through HTTP

A ruby Logger that sends UDP directly to a remote syslog endpoint

A quick and lightweight tool for creating searchable change control logs. Writes to logstash using json over TCP

Resque-based background worker to send Apple Push Notifications over a persistent TCP socket. Includes Resque tweaks to allow persistent sockets between jobs, helper methods for enqueueing APN notifications, and a background daemon to send them.

Sockd makes it easy to create a single-threaded daemon which can listen on a TCP or Unix socket and respond to commands

A TCP client for Precidia's POSLynx™ devices

An asyncronous tcp socket for ruby

Parse RTCP data into Ruby objects

alo7-net is the TCP server/client library we developed specifically for our ALO7 Learning Platform. This library provides a way to write asynchronous code in a straight-line fashion using fibers.

Polytalk is a simple protocol which allows communication between different languages via TCP.

Library to send GELF messages to Graylog logging server. Supports plain-text, GELF messages and exceptions via UDP and TCP.

A tool to inspect/dump/handle message to Fluentd TCP input.

Send logging information in JSON format via TCP to an instance of Graylog