process-roulette 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e169b9806e4eeefe32ec16341caa1a05acf79c38
+  data.tar.gz: 3d92f020ff0e571ee1497c8d82754b078f05ed36
+SHA512:
+  metadata.gz: 1c470fb7760097d8648fb262474c2415daa1c8ace730b2ed96c72a93e068c781eba850711ba7542035c12e7bea0207dfe70bc532ae9559fdcf12c9629e860743
+  data.tar.gz: ebf0276cdd0365ee54345a9a35fe43232c994dc9ff97ee014a342b18090f2ce2b303b70a886153839f9b04e2fb9da0c3953e6d10e805fbd86f825fe50fddbf7f

data/LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2016 Jamis Buck <jamis@jamisbuck.org>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,67 @@
+# Process Roulette
+
+This started as a throw-away tweet:
+https://twitter.com/jamis/status/808779302468665344 . Only I couldn't stop
+thinking about it...and then I needed a project to start experimenting with
+[atom](https://atom.io/) and [Rubocop](http://rubocop.readthedocs.io/en/latest/)...
+and the next thing I knew, I was working on this.
+
+It's still a work-in-progress, and is not guaranteed to work, and is most
+_definitely_ not guaranteed to be safe. (I mean, heck, the whole _point_ of
+this is to randomly kill processes on your machine. Use with extreme
+caution!)
+
+
+## Overview
+
+There are three components to process roulette:
+
+* The _croupier_. This is a supervisor that oversees the game. Start it running
+  on some machine (preferably one that will not be used during the roulette
+  game). The players and controllers will connect to the croupier, which will
+  referee the game.
+* The _player_. Each player should be running in a virtual machine (or, at the
+  very least, on a box that you absolutely despise). Do _not_ run this process
+  on any machine that you care about! It's job is to connect to the croupier
+  service, and then (when the croupier gives the "go" signal) proceed to whack
+  random processes until the machine crashes. _You have been warned._
+* The _controller_. Each controller should be running somewhere far away from
+  the players. They connect to the croupier service, and are used to control
+  the game. The controller says "go", and "exit", and the controller is told
+  the results of the game. If you begin a controller without a password, it is
+  considered a _spectator_, allowed to watch the bout and see the results, but
+  not to control it in any way.
+
+
+## Running a game
+
+First, install process-roulette:
+
+    $ gem install process-roulette
+
+Then, start the croupier service.
+
+    $ croupier -p <port> <password>
+
+Then, start players, controllers and spectators.
+
+    $ roulette-ctl host:port password
+    $ roulette-ctl host:port
+    $ sudo roulette-player username@host:port
+
+Note that the player must be run as the superuser, otherwise it won't be able
+to whack the really important processes!
+
+When everyone is joined, one of the controllers issues the "GO" command, and
+the rest happens automatically!
+
+
+## License
+
+This software is made available under the terms of the MIT license. (See the
+LICENSE file for full details.)
+
+
+## Author
+
+This software is written by Jamis Buck (<jamis@jamisbuck.org>).

data/bin/croupier

@@ -0,0 +1,26 @@
+#!/bin/sh ruby
+
+require 'optparse'
+require 'process/roulette/croupier'
+
+port = 11_234
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{$PROGRAM_NAME} [options] password"
+
+  opts.on '-h', '--help', 'Display this text' do
+    puts opts
+    exit
+  end
+
+  opts.on '-p', '--port N', Integer,
+          'The port to accept connections on' do |p|
+    port = p
+  end
+end.parse!
+
+password = ARGV.shift || abort('you must supply a password')
+
+puts "Starting croupier process on port #{port}"
+croupier = Process::Roulette::Croupier.new(port, password)
+croupier.run

data/bin/roulette-ctl

@@ -0,0 +1,24 @@
+#!/bin/sh ruby
+
+require 'optparse'
+require 'process/roulette/controller'
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{$PROGRAM_NAME} [options] host:port [password]"
+
+  opts.on '-h', '--help', 'Display this text' do
+    puts opts
+    exit
+  end
+end.parse!
+
+host_port = ARGV.shift || abort('you must specify the destination host:port')
+password = ARGV.shift
+
+host, port = host_port.split(/:/, 2)
+
+type = password ? 'controller' : 'spectator'
+puts "Starting #{type} process..."
+
+controller = Process::Roulette::Controller.new(host, port.to_i, password)
+controller.run

data/bin/roulette-player

@@ -0,0 +1,26 @@
+#!/bin/sh ruby
+
+require 'optparse'
+require 'process/roulette/player'
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{$PROGRAM_NAME} [options] user@host:port"
+
+  opts.on '-h', '--help', 'Display this text' do
+    puts opts
+    exit
+  end
+end.parse!
+
+dest = ARGV.shift || abort('you must specify user@host:port')
+matches = dest.match(/^(?<user>.*)@(?<host>.*):(?<port>\d+)$/)
+if matches
+  user = matches[:user]
+  host = matches[:host]
+  port = matches[:port].to_i
+else
+  abort 'destination must be formatted like user@host:port'
+end
+
+player = Process::Roulette::Player.new(host, port, user)
+player.play

data/lib/process/roulette/controller.rb

@@ -0,0 +1,16 @@
+require 'process/roulette/controller/driver'
+
+module Process
+  module Roulette
+
+    # Delegates to Controller::Driver
+    module Controller
+
+      def self.new(host, port, password = nil)
+        Driver.new(host, port, password)
+      end
+
+    end
+
+  end
+end

data/lib/process/roulette/controller/command_handler.rb

@@ -0,0 +1,123 @@
+require 'process/roulette/controller/game_handler'
+require 'process/roulette/controller/finish_handler'
+
+module Process
+  module Roulette
+    module Controller
+
+      # Handles the COMMAND state of the controller state machine. Listens to
+      # both STDIN (unless we're a spectator) and the socket and acts
+      # accordingly.
+      class CommandHandler
+        def initialize(driver)
+          @driver = driver
+          @next_handler = nil
+        end
+
+        def run
+          STDOUT.sync = true
+          _say 'waiting for bout to begin'
+
+          while @next_handler.nil?
+            ready = _wait_for_input
+            @driver.socket.send_packet('PING')
+
+            ready.each do |io|
+              _process_ready_socket(io)
+            end
+          end
+
+          @next_handler == :quit ? nil : @next_handler
+        end
+
+        def _say(message, update_prompt = true)
+          puts unless @driver.spectator?
+          puts message if message
+          print 'controller> ' if update_prompt && !@driver.spectator?
+        end
+
+        def _wait_for_input
+          ios = [ @driver.socket ]
+          ios << STDIN unless @driver.spectator?
+
+          ready, = IO.select(ios, [], [], 0.2)
+          ready || []
+        end
+
+        def _process_ready_socket(io)
+          if io == STDIN
+            _process_user_input
+          elsif io == @driver.socket
+            _process_croupier_input
+          end
+        end
+
+        def _process_user_input
+          command = (STDIN.gets || '').strip.upcase
+
+          case command
+          when '', 'QUIT'  then @next_handler = :quit
+          when 'EXIT'      then _invoke_exit
+          when 'GO'        then _invoke_go
+          when 'HELP', '?' then _invoke_help
+          else                  _invoke_error(command)
+          end
+        end
+
+        def _invoke_exit
+          _say 'telling croupier to terminate'
+          @driver.socket.send_packet('EXIT')
+        end
+
+        def _invoke_go
+          _say 'telling croupier to start game'
+          @driver.socket.send_packet('GO')
+        end
+
+        def _invoke_help
+          puts 'Ok. I understand these commands:'
+          puts ' - EXIT (terminates the croupier)'
+          puts ' - QUIT (terminates just this controller)'
+          puts ' - GO (starts the bout)'
+          puts ' - HELP (this page)'
+          _say nil
+        end
+
+        def _process_croupier_input
+          packet = @driver.socket.read_packet
+
+          case packet
+          when nil, 'EXIT' then _handle_exit
+          when 'GO' then _handle_go
+          when /^UPDATE:(.*)/ then _handle_update(Regexp.last_match(1))
+          else _handle_unexpected(packet)
+          end
+        end
+
+        def _invoke_error(text)
+          _say "#{text.inspect} is not understood", false
+          _invoke_help
+        end
+
+        def _handle_exit
+          _say 'croupier is terminating. bye!', false
+          @next_handler = Controller::FinishHandler
+        end
+
+        def _handle_go
+          _say nil, false
+          @next_handler = Controller::GameHandler
+        end
+
+        def _handle_update(msg)
+          _say msg
+        end
+
+        def _handle_unexpected(packet)
+          _say "unexpected message from croupier: #{packet.inspect}"
+        end
+      end
+
+    end
+  end
+end

data/lib/process/roulette/controller/connect_handler.rb

@@ -0,0 +1,39 @@
+require 'socket'
+require 'process/roulette/enhance_socket'
+require 'process/roulette/controller/command_handler'
+
+module Process
+  module Roulette
+    module Controller
+
+      # Handles the CONNECT state of the controller state machine. Connects
+      # to the croupier, performs the handshake, and advances to COMMAND state.
+      class ConnectHandler
+        def initialize(driver)
+          @driver = driver
+        end
+
+        def run
+          puts 'connecting...'
+
+          socket = TCPSocket.new(@driver.host, @driver.port)
+          Roulette::EnhanceSocket(socket)
+
+          _handshake(socket)
+          @driver.socket = socket
+
+          Controller::CommandHandler
+        end
+
+        def _handshake(socket)
+          socket.send_packet(@driver.password || 'OK')
+
+          packet = socket.wait_with_ping
+          abort 'lost connection' unless packet
+          abort "unexpected packet #{packet.inspect}" unless packet == 'OK'
+        end
+      end
+
+    end
+  end
+end

data/lib/process/roulette/controller/driver.rb

@@ -0,0 +1,56 @@
+require 'process/roulette/controller/connect_handler'
+
+module Process
+  module Roulette
+    module Controller
+
+      # Encapsulates both the controller and spectator behavior. If the password
+      # is nil, the controller is considered a spectator, allowed to watch the
+      # bout, but not to control it.
+      #
+      # It's state machine works as follows:
+      #
+      #   CONNECT
+      #     - connects to croupier, performs handshake
+      #     - advances to COMMAND
+      #   COMMAND
+      #     - waits for input from terminal (unless spectator)
+      #       * "GO" => sends "GO" to croupier
+      #       * "EXIT" => sends "EXIT" to croupier
+      #     - listens for commands from croupier
+      #       * "GO" => advances to GAME
+      #       * "EXIT" => advances to FINISH
+      #   GAME
+      #     - listens for updates from croupier
+      #       # "GO" => begins next round
+      #       * "UPDATE" => print update from croupier
+      #       * "DONE" => advances to DONE
+      #   DONE
+      #     - diplays final scoreboard
+      #     - advances to COMMAND
+      #   FINISH
+      #     - closes sockets, terminates
+      #
+      class Driver
+        attr_reader :host, :port, :password
+        attr_accessor :socket
+
+        def initialize(host, port, password = nil)
+          @host = host
+          @port = port
+          @password = password
+        end
+
+        def spectator?
+          password.nil?
+        end
+
+        def run
+          handler = Controller::ConnectHandler
+          handler = handler.new(self).run while handler
+        end
+      end
+
+    end
+  end
+end

data/lib/process/roulette/controller/finish_handler.rb

@@ -0,0 +1,21 @@
+module Process
+  module Roulette
+    module Controller
+
+      # Handles the FINISH state of the controller state machine, by
+      # disconnecting from the croupier.
+      class FinishHandler
+        def initialize(driver)
+          @driver = driver
+        end
+
+        def run
+          puts 'terminating...'
+          @driver.socket.close
+          nil
+        end
+      end
+
+    end
+  end
+end

data/lib/process/roulette/controller/game_handler.rb

@@ -0,0 +1,84 @@
+require 'process/roulette/controller/command_handler'
+
+module Process
+  module Roulette
+    module Controller
+
+      # Handles the GAME state of the controller state machine.
+      class GameHandler
+        def initialize(driver)
+          @driver = driver
+        end
+
+        def run
+          puts 'BOUT BEGINS'
+
+          @bout_active = true
+          @round = 1
+
+          while @bout_active
+            _process_input if _wait_for_input
+            @driver.socket.send_packet('PING')
+          end
+
+          Controller::CommandHandler
+        end
+
+        def _wait_for_input
+          ready, = IO.select([@driver.socket], [], [], 0.2)
+          ready ? ready.first : nil
+        end
+
+        def _process_input
+          packet = @driver.socket.read_packet
+
+          case packet
+          when nil then abort 'disconnected!'
+          when 'GO' then _start_next_round
+          when 'DONE' then _finish_bout
+          when /^UPDATE:(.*)/ then _report_update(Regexp.last_match(1))
+          else _handle_unexpected(packet)
+          end
+        end
+
+        def _start_next_round
+          @round += 1
+          puts "- ROUND #{@round}"
+        end
+
+        def _finish_bout
+          puts 'BOUT FINISHED'
+          @bout_active = false
+
+          scoreboard = @driver.socket.read_packet
+          _display_scoreboard(scoreboard)
+
+          puts
+        end
+
+        def _report_update(message)
+          puts "- #{message}"
+        end
+
+        def _handle_unexpected(packet)
+          puts "- unexpected message from croupier (#{packet.inspect})"
+        end
+
+        def _display_scoreboard(scoreboard)
+          _scoreboard_header
+          scoreboard.each.with_index do |player, index|
+            puts format('%2d | %-10s | %-10s | %5d',
+                        index + 1, player[:name],
+                        player[:killer], player[:victims].length)
+          end
+        end
+
+        def _scoreboard_header
+          puts format('   | %-10s | %-10s | %-6s', 'Name', 'Killer', 'Rounds')
+          puts format('---+-%10s-+-%10s-+-%6s', '-' * 10, '-' * 10, '-' * 6)
+        end
+      end
+
+    end
+  end
+end

data/lib/process/roulette/croupier.rb

@@ -0,0 +1,16 @@
+require 'process/roulette/croupier/driver'
+
+module Process
+  module Roulette
+
+    # The Croupier is actually backed by Croupier::Driver
+    module Croupier
+
+      def self.new(port, password)
+        Driver.new(port, password)
+      end
+
+    end
+
+  end
+end

data/lib/process/roulette/croupier/controller_socket.rb

@@ -0,0 +1,17 @@
+module Process
+  module Roulette
+
+    # Enhances controller sockets so that controllers can be differentiated
+    # from mere spectators.
+    module ControllerSocket
+      def spectator!
+        @spectator = true
+      end
+
+      def spectator?
+        @spectator
+      end
+    end
+
+  end
+end

data/lib/process/roulette/croupier/driver.rb

@@ -0,0 +1,77 @@
+require 'socket'
+require 'process/roulette/croupier/join_handler'
+require 'process/roulette/enhance_socket'
+
+module Process
+  module Roulette
+    module Croupier
+
+      # The croupier is the person who runs a roulette table
+      #
+      # Croupier is started with a password (see WAIT state, below)
+      #
+      # STATES
+      # - JOIN
+      #   * accept connections
+      #   * if a connection says :OK, they are added to player list
+      #     - should include a desired username
+      #     - if username is already taken, reject connection
+      #     - if accepted, server sends :OK
+      #   * if a connection gives password, they are added to controller list
+      #   * all connections must send a :PING at least every 1000ms or be
+      #     discarded
+      #   * when controller says :EXIT, advance to FINISH
+      #   * when controller says :GO, state advances to START and no further
+      #     connections are accepted (listening socket is closed)
+      # - START
+      #   * sends :GO to all players
+      #   * players reply with name/pid of process they will kill
+      #   * players must next respond with :OK after killing the process
+      #   * if player does not reply within 1000ms they are flagged "DEAD"
+      #   * if all players are flagged "DEAD", advance to RESTART
+      #   * when either all players have responded with :OK, or 1000ms have
+      #     elapsed, advance to START
+      # - RESTART
+      #   * send 'DONE' to controllers
+      #   * send final score info to controllers
+      #   * cleanup
+      #   * advance to JOIN
+      # - FINISH
+      #   * notify all players and controllers that server is ending
+      #   * cleanup
+      #   * exit
+      class Driver
+        attr_reader :port, :password
+        attr_reader :players, :controllers
+
+        def initialize(port, password)
+          @port = port
+          @password = password
+
+          @players = []
+          @controllers = []
+        end
+
+        def reap!
+          @players.delete_if(&:dead?)
+          @controllers.delete_if(&:dead?)
+        end
+
+        def sockets
+          @players + @controllers
+        end
+
+        def broadcast_update(message)
+          payload = "UPDATE:#{message}"
+          @controllers.each { |s| s.send_packet(payload) }
+        end
+
+        def run
+          next_state = Croupier::JoinHandler
+          next_state = next_state.new(self).run while next_state
+        end
+      end
+
+    end
+  end
+end

data/lib/process/roulette/croupier/finish_handler.rb

@@ -0,0 +1,25 @@
+module Process
+  module Roulette
+    module Croupier
+
+      # The FinishHandler encapsulates the "finish" state of the croupier state
+      # machine. It closes all player and controller sockets and terminates
+      # the state machine.
+      class FinishHandler
+        def initialize(croupier)
+          @croupier = croupier
+        end
+
+        def run
+          @croupier.sockets.each do |socket|
+            socket.send_packet('EXIT')
+            socket.close
+          end
+
+          nil
+        end
+      end
+
+    end
+  end
+end

data/lib/process/roulette/croupier/join_handler.rb

@@ -0,0 +1,139 @@
+require 'process/roulette/croupier/join_pending'
+require 'process/roulette/croupier/start_handler'
+require 'process/roulette/croupier/finish_handler'
+
+module Process
+  module Roulette
+    module Croupier
+
+      # The JoinHandler encapsulates the "join" state of the croupier state
+      # machine. It listens for new connections, builds up the lists of players
+      # controllers, and indicates the next state (either 'start' or
+      # 'finish') based on the input from the controllers.
+      class JoinHandler
+        def initialize(driver)
+          @driver = driver
+          @pending = JoinPending.new(driver)
+          @next_state = nil
+        end
+
+        def run
+          @driver.players.clear
+
+          puts 'listening...'
+          listener = TCPServer.new(@driver.port)
+
+          _process_current_state(listener)
+          @pending.cleanup!
+
+          listener.close
+
+          @next_state
+        end
+
+        def _process_current_state(listener)
+          until @next_state
+            ready = _wait_for_connections(listener)
+            _process_ready_list(ready, listener)
+
+            @pending.reap!
+            @driver.reap!
+          end
+        end
+
+        def _wait_for_connections(*extras)
+          ready, = IO.select(
+            [*extras, *@pending, *@driver.sockets],
+            [], [], 1)
+
+          ready || []
+        end
+
+        def _process_ready_list(list, listener)
+          list.each do |socket|
+            if socket == listener
+              _process_new_connection(socket)
+            else
+              _process_participant_connection(socket)
+            end
+          end
+        end
+
+        def _process_new_connection(socket)
+          puts 'new pending connection...'
+          client = socket.accept
+          @pending << Process::Roulette::EnhanceSocket(client)
+        end
+
+        def _process_participant_connection(socket)
+          packet = socket.read_packet
+          socket.ping! if packet
+
+          if @pending.include?(socket)
+            @pending.process(socket, packet)
+          elsif @driver.controllers.include?(socket)
+            _process_controller_packet(socket, packet)
+          else
+            _process_player_packet(socket, packet)
+          end
+        end
+
+        def _process_controller_packet(socket, packet)
+          if socket.spectator?
+            _process_spectator_packet(socket, packet)
+          else
+            _process_real_controller_packet(socket, packet)
+          end
+        end
+
+        def _process_real_controller_packet(socket, packet)
+          case packet
+          when nil    then _controller_disconnected(socket)
+          when 'GO'   then _controller_go
+          when 'EXIT' then _controller_exit
+          when 'PING' then nil
+          else puts "unexpected command from controller (#{packet.inspect})"
+          end
+        end
+
+        def _process_spectator_packet(socket, packet)
+          case packet
+          when nil    then _controller_disconnected(socket)
+          when 'PING' then # do nothing
+          else puts "unexpected comment from spectator (#{packet.inspect})"
+          end
+        end
+
+        def _controller_disconnected(socket)
+          type = socket.spectator? ? 'spectator' : 'controller'
+          @driver.broadcast_update("#{type} has disconnected")
+          @driver.controllers.delete(socket)
+        end
+
+        def _controller_go
+          puts 'command given to start'
+          @next_state = StartHandler
+        end
+
+        def _controller_exit
+          puts 'command given to exit'
+          @next_state = FinishHandler
+        end
+
+        def _process_player_packet(socket, packet)
+          case packet
+          when nil    then _player_disconnected(socket)
+          when 'PING' then # do nothing
+          else puts "unexpected comment from player (#{packet.inspect})"
+          end
+        end
+
+        def _player_disconnected(socket)
+          @driver.broadcast_update "player #{socket.username} has disconnected"
+          @driver.players.delete(socket)
+        end
+      end
+
+    end
+  end
+end

data/lib/process/roulette/croupier/join_pending.rb

@@ -0,0 +1,103 @@
+require 'process/roulette/croupier/controller_socket'
+
+module Process
+  module Roulette
+    module Croupier
+
+      # The JoinPending class encapsulates the handling of pending connections
+      # during the 'join' phase of the croupier state machine. It explicitly
+      # handles new player and new controller connections, moving them from
+      # the pending list to the appropriate collections of the croupier itself,
+      # depending on their handshake.
+      class JoinPending < Array
+        def initialize(driver)
+          super()
+          @driver = driver
+        end
+
+        def reap!
+          delete_if(&:dead?)
+        end
+
+        def cleanup!
+          return unless any?
+
+          puts 'closing pending connections'
+          each(&:close)
+        end
+
+        def process(socket, packet)
+          _handle_nil(socket, packet) ||
+            _handle_new_player(socket, packet) ||
+            _handle_new_controller(socket, packet, @driver.password) ||
+            _handle_new_controller(socket, packet, 'OK') ||
+            _handle_ping(socket, packet) ||
+            _handle_unexpected(socket, packet)
+        end
+
+        def _handle_nil(socket, packet)
+          return false unless packet.nil?
+          puts 'pending socket closed'
+          delete(socket)
+          true
+        end
+
+        def _handle_new_player(socket, packet)
+          return false unless /^OK:(?<username>.*)/ =~ packet
+
+          socket.username = username
+          delete(socket)
+
+          if @driver.players.any? { |p| p.username == socket.username }
+            _player_username_taken(socket)
+          else
+            _player_accepted(socket)
+          end
+
+          true
+        end
+
+        def _handle_new_controller(socket, packet, password)
+          return false unless packet == password
+
+          socket.extend(ControllerSocket)
+          socket.spectator! if password == 'OK'
+
+          puts format('accepting new %s',
+                      socket.spectator? ? 'spectator' : 'controller')
+          socket.send_packet('OK')
+          delete(socket)
+          @driver.controllers << socket
+
+          true
+        end
+
+        def _handle_ping(_socket, packet)
+          return false unless packet == 'PING'
+          true
+        end
+
+        def _handle_unexpected(_socket, packet)
+          puts "unexpected input from pending socket (#{packet.inspect})"
+          true
+        end
+
+        def _player_username_taken(socket)
+          puts 'rejecting: username already taken'
+          socket.send_packet('username already taken')
+          socket.close
+        end
+
+        def _player_accepted(socket)
+          puts "accepting new player #{socket.username}"
+          socket.send_packet('OK')
+          @driver.players << socket
+          @driver.broadcast_update(
+            "player '#{socket.username}' added" \
+            " (#{@driver.players.length} total)")
+        end
+      end
+
+    end
+  end
+end

data/lib/process/roulette/croupier/restart_handler.rb

@@ -0,0 +1,45 @@
+require 'process/roulette/croupier/join_handler'
+
+module Process
+  module Roulette
+    module Croupier
+
+      # The RestartHandler encapsulates the "restart" state of the croupier
+      # state machine. It builds a scoreboard of results from the most recent
+      # game and sends it to all controllers, and then advances the state
+      # machine to the "join" state.
+      class RestartHandler
+        def initialize(croupier)
+          @croupier = croupier
+        end
+
+        def run
+          scoreboard = _sorted_players.map do |player|
+            _results_for(player)
+          end
+
+          @croupier.controllers.each do |controller|
+            controller.send_packet('DONE')
+            controller.send_packet(scoreboard)
+          end
+
+          JoinHandler
+        end
+
+        def _sorted_players
+          @croupier.players.sort_by { |player| -player.victims.length }
+        end
+
+        def _results_for(player)
+          {
+            name:      player.username,
+            killed_at: player.killed_at,
+            killer:    player.victims.last,
+            victims:   player.victims
+          }
+        end
+      end
+
+    end
+  end
+end

data/lib/process/roulette/croupier/start_handler.rb

@@ -0,0 +1,109 @@
+require 'process/roulette/croupier/restart_handler'
+
+module Process
+  module Roulette
+    module Croupier
+
+      # The StartHandler encapsulates the "start" state of the croupier state
+      # machine. It sends "GO" to all players, listens for their replies
+      # with the processes they intend to kill, and waits for all players to
+      # check in afterward. It manages the list if active players (removing
+      # those that fail to check-in) and transitions to the "restart" state
+      # when all players are dead.
+      class StartHandler
+        def initialize(driver)
+          @driver = driver
+        end
+
+        def run
+          @standing = _prepare_live_players
+          @started = Time.now
+
+          until _all_players_confirmed? || _time_elapsed?
+            ready = _wait_for_input
+            _process_ready_sockets(ready)
+          end
+
+          remaining = _kill_unconfirmed_players
+          remaining.any? ? StartHandler : RestartHandler
+        end
+
+        def _wait_for_input
+          ready, = IO.select([*@standing, *@driver.controllers], [], [], 1)
+          ready || []
+        end
+
+        def _time_elapsed?
+          (Time.now - @started) > 1.0
+        end
+
+        def _all_players_confirmed?
+          @standing.all?(&:confirmed?)
+        end
+
+        def _prepare_live_players
+          standing = @driver.players.select { |s| !s.killed? }
+
+          @driver.controllers.each do |s|
+            s.send_packet('GO')
+          end
+
+          standing.each do |s|
+            s.victim = nil
+            s.confirmed! false
+            s.send_packet('GO')
+          end
+        end
+
+        def _kill_unconfirmed_players
+          @standing.select do |s|
+            next true if s.confirmed?
+            _player_died(s, remove: false)
+            false
+          end
+        end
+
+        def _process_ready_sockets(list)
+          list.each do |socket|
+            packet = socket.read_packet
+            socket.ping! if packet
+
+            if packet.nil?            then _handle_closed_socket(socket)
+            elsif _is_player?(socket) then _handle_player(socket, packet)
+            elsif packet != 'PING'
+              puts "unexpected comment from controller #{packet.inspect}"
+            end
+          end
+        end
+
+        def _is_player?(socket)
+          @standing.include?(socket)
+        end
+
+        def _handle_closed_socket(socket)
+          if @standing.include?(socket)
+            _player_died(socket)
+          else
+            @controllers.delete(socket)
+          end
+        end
+
+        def _player_died(socket, remove: true)
+          socket.killed_at = Time.now
+          socket.close
+          @driver.broadcast_update("#{socket.username} died")
+          @standing.delete(socket) if remove
+        end
+
+        def _handle_player(socket, packet)
+          if socket.has_victim? && packet == 'OK'
+            socket.confirmed!
+          else
+            socket.victim = packet
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/process/roulette/enhance_socket.rb

@@ -0,0 +1,82 @@
+module Process
+  module Roulette # rubocop:disable Style/Documentation
+
+    # A factory method for applying the EnhanceSocket module to a socket.
+    # It adds the module, and automatically calls #ping!, to ensure that
+    # the socket begins in an "alive" state.
+    def self.EnhanceSocket(socket) # rubocop:disable Style/MethodName
+      socket.tap do |s|
+        s.extend(EnhanceSocket)
+        s.ping!
+      end
+    end
+
+    # A module that adds helper methods to socket objects. In particular,
+    # it makes it easier to read and write entire packets (where a packet is
+    # defined as a 4-byte length field, followed by a variable length body,
+    # and the body is a marshalled Ruby object.)
+    module EnhanceSocket
+      def read_packet
+        raw = recv(4, 0)
+        return nil if raw.empty?
+
+        length = raw.unpack('N').first
+        raw = recv(length, 0)
+        return nil if raw.empty?
+
+        Marshal.load(raw)
+      end
+
+      def send_packet(payload)
+        body = Marshal.dump(payload)
+        len = [body.length].pack('N')
+        send(len, 0)
+        send(body, 0)
+        body.length
+      end
+
+      def wait_with_ping
+        loop do
+          ready, = IO.select([self], [], [], 0.2)
+          return read_packet if ready && ready.any?
+
+          send_packet('PING')
+        end
+      end
+
+      attr_accessor :username
+      attr_accessor :victims
+      attr_accessor :killed_at
+
+      def killed?
+        @killed_at != nil
+      end
+
+      def has_victim?
+        @current_victim != nil
+      end
+
+      def victim=(v)
+        @current_victim = v
+        (@victims ||= []).push(v) if v
+      end
+
+      def confirmed?
+        @confirmed
+      end
+
+      def confirmed!(confirm = true)
+        @confirmed = confirm
+      end
+
+      def ping!
+        @last_ping = Time.now.to_f
+      end
+
+      def dead?
+        Time.now.to_f - @last_ping > 1.0
+      end
+    end
+
+  end
+end

data/lib/process/roulette/player.rb

@@ -0,0 +1,79 @@
+require 'socket'
+require 'process/roulette/enhance_socket'
+
+require 'sys/proctable'
+
+module Process
+  module Roulette
+
+    # Encapsulates the player entity, participating in the roulette game by
+    # killing random processes in coordination with the croupier server.
+    class Player
+      def initialize(host, port, username)
+        @host = host
+        @port = port
+        @username = username
+      end
+
+      def play
+        puts 'connecting...'
+        socket = Process::Roulette::EnhanceSocket(TCPSocket.new(@host, @port))
+
+        _handshake(socket)
+        _play_loop(socket)
+
+        puts 'finishing...'
+        socket.close
+      end
+
+      def _handshake(socket)
+        socket.send_packet("OK:#{@username}")
+
+        packet = socket.wait_with_ping
+        abort 'lost connection' unless packet
+
+        return if packet == 'OK'
+
+        socket.close
+        abort 'username already taken!'
+      end
+
+      def _play_loop(socket)
+        loop do
+          packet = socket.wait_with_ping
+          abort 'lost connection' unless packet
+
+          break if _handle_packet(socket, packet)
+        end
+      end
+
+      def _handle_packet(socket, packet)
+        if packet == 'GO'
+          _pull_trigger(socket)
+
+          puts 'survived!'
+          socket.send_packet('OK')
+        else
+          puts "unexpected packet: #{packet.inspect}"
+        end
+
+        false
+      end
+
+      def _pull_trigger(socket)
+        processes = ::Sys::ProcTable.ps
+        victim = processes.sample
+
+        # alternatively: write to random memory locations?
+        socket.send_packet(victim.comm)
+
+        puts "pulling the trigger on \##{victim.pid} (#{victim.comm})"
+        Process.kill('KILL', victim.pid)
+
+        # give some time to make sure the kill has its effect
+        sleep 0.1
+      end
+    end
+
+  end
+end

data/lib/process/roulette/version.rb

@@ -0,0 +1,5 @@
+module Process
+  module Roulette
+    VERSION = '1.0.0'.freeze
+  end
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: process-roulette
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jamis Buck
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-12-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sys-proctable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  Play roulette with your computer! Randomly kill processes until your machine
+  crashes. The person who lasts the longest, wins! (Best enjoyed in a VM, and
+  with friends.)
+email:
+- jamis@jamisbuck.org
+executables:
+- croupier
+- roulette-ctl
+- roulette-player
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/croupier
+- bin/roulette-ctl
+- bin/roulette-player
+- lib/process/roulette/controller.rb
+- lib/process/roulette/controller/command_handler.rb
+- lib/process/roulette/controller/connect_handler.rb
+- lib/process/roulette/controller/driver.rb
+- lib/process/roulette/controller/finish_handler.rb
+- lib/process/roulette/controller/game_handler.rb
+- lib/process/roulette/croupier.rb
+- lib/process/roulette/croupier/controller_socket.rb
+- lib/process/roulette/croupier/driver.rb
+- lib/process/roulette/croupier/finish_handler.rb
+- lib/process/roulette/croupier/join_handler.rb
+- lib/process/roulette/croupier/join_pending.rb
+- lib/process/roulette/croupier/restart_handler.rb
+- lib/process/roulette/croupier/start_handler.rb
+- lib/process/roulette/enhance_socket.rb
+- lib/process/roulette/player.rb
+- lib/process/roulette/version.rb
+homepage: https://github.com/jamis/process_roulette
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: A roulette party game for devs
+test_files: []