tmux-connector 0.0.2

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Ivan Kusalic
+
+MIT License
+
+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,352 @@
+# TmuxConnector
+
+Manage multiple servers using SSH and [tmux].
+
+
+## Features:
+* work on multiple sessions in parallel
+* sessions can be persisted (actually recreated) after computer restarts
+    - they are lost only if you delete them explicitly
+* complex layouts customizable for different server groups
+* issuing commands to all servers or just a selected subgroups
+
+## Quick tease
+
+`tcon start staging_config.yml -n staging -p 'all staging servers'`
+
+- crate a session (name: 'staging', description: 'all staging servers') with
+    complex layout structure (multiple windows with (potentially) different pane
+    layouts)
+- connect to all servers
+- attach to tmux session
+
+`tcon send staging 'sudo su'`
+
+- send to all servers (in 'staging' session) `sudo su` command
+
+`tcon send staging 'top' -g 'lbs'`
+
+- send `top` command to all loadbalancing nodes in 'staging' session
+
+`tcon send production 'tail -f' -f 'rdb'`
+
+- send `tail -f` command to all database nodes in 'production' session
+
+`tcon resume s#3`
+
+- resume (recreate) 's#3' session, even after computer restart
+
+
+## CLI description
+
+[CLI] uses [docopt] to parse command line options.
+
+~~~
+tcon enables establishing connections (ssh) to multiple servers and executing
+commands on those servers. The sessions can be persisted (actually recreated)
+even after computer restarts. Complex sessions with different layouts for
+different kinds of servers can be easily created.
+
+Usage:
+  tcon start <config-file> [--ssh-config=<file>]
+             [--session-name=<name>] [--purpose=<description>]
+  tcon resume <session-name>
+  tcon delete (<session-name> | --all)
+  tcon list
+  tcon send <session-name> (<command> | --command-file=<file>)
+            [--server-filter=<regex>] [--group-filter=<regex>] [--verbose]
+  tcon --help
+  tcon --version
+
+Options:
+  <config-file>              Path to configuration file. Configuration file
+                             describes how new session is started. YAML format.
+  <session-name>             Name that identifies the session. Must be unique.
+  <command>                  Command to be executed on remote server[s].
+  -s --ssh-config=file       Path to ssh config file [default: ~/.ssh/config].
+  -n --session-name=name     Name of the session to be used in the tcon command.
+  -p --purpose=description   Description of session's purpose.
+  --all                      Delete all existing sessions.
+  -f --server-filter=regex   Filter to select a subset of the servers.
+                             Should be valid ruby regex.
+  -g --group-filter=regex    Filter to select a subset of the servers via
+                             group membership.  Should be valid ruby regex.
+  -c --command-file=file     File containing the list of commands to be
+                             executed on remote server[s].
+  -v --verbose               Report how many servers were affected by the send
+                             command.
+  -h --help                  Show this screen.
+  --version                  Show version.
+~~~
+
+
+## Configuration
+
+To use this gem, you need to create a configuration file. This shouldn't be
+that hard and here I provide exhaustive details about configuration files.
+
+(If there is enough interest, in future versions there could be a special
+command to simplify generation of configuration files. To accelerate the
+process, open an issue or drop me an email: << username >>@gmail.com)
+
+Let's get to it.
+
+The configuration file is in [YAML] format.
+
+Let's say the following ssh config file that will be used:
+~~~
+KeepAlive yes
+ServerAliveInterval 2
+StrictHostKeyChecking no
+UserKnownHostsFile=/dev/null
+
+Host staging.cache-staging-1
+  Hostname ec2-111-42-111-42.eu-west-1.compute.amazonaws.com
+  Port 4242
+  IdentityFile /Users/ikusalic/.ssh/some-pem-file.pem
+  User ubuntu
+
+Host dev.database-staging-1
+  << omitted >>
+
+Host dev.database-staging-3
+  << omitted >>
+
+Host dev.mongodb-single-replica-1
+  << omitted >>
+
+Host dev.haproxy-staging-72
+  << omitted >>
+
+Host dev.haproxy-staging-73
+  << omitted >>
+
+Host dev.nginx-staging-11
+  << omitted >>
+
+Host dev.nginx-staging-15
+  << omitted >>
+
+Host dev.node-staging-127
+  << omitted >>
+
+Host dev.node-staging-129
+  << omitted >>
+
+Host dev.node-staging-130
+  << omitted >>
+
+Host dev.node-staging-135
+  << omitted >>
+
+<< ... >>
+~~~
+
+Here's a 'real world' configuration file that shows of all the available
+options and could be use with previous ssh config file:
+
+~~~yaml
+regex: !ruby-regexp '^(\w+)\.(\w+)-([\w-]+)-(\d+)$'
+reject-regex: !ruby-regexp '-(nodes|to_ignore)-'
+regex-parts-to:
+    group-by: [1]
+    sort-by: [3]
+name:
+    regex-ignore-parts: [0, 2]
+    separator: '-'
+    prefix: 'dev--'
+merge-groups:
+    misc: ['cache', 'db', 'mongodb']
+    lbs: ['haproxy', 'nginx']
+layout:
+    default:
+        custom:
+            max-horizontal: 3
+            max-vertical: 3
+            panes-flow: vertical
+    group-layouts:
+         misc:
+            tmux:
+                layout: 'tiled'
+                max-panes: 6
+         node:
+            tmux:
+                layout: 'tiled'
+~~~
+
+* * *
+__'regex'__ field is the most important field. Some other field reference
+this one. It provides a rule on how to parse host names from ssh config file.
+The regex should be a valid ruby regex. (If you're not familiar with ruby
+regexes, consider visiting [rubulator] and playing around.)
+
+All host whose host names fail the regex will be ignored.
+
+For example if ssh config file include the following host definition:
+~~~
+Host dev.database-staging-1
+~~~
+
+and the following regex is used:
+~~~
+regex: !ruby-regexp '^(\w+)\.(\w+)-([\w-]+)-(\d+)$'
+~~~
+
+the name 'dev.database-staging-1' will be broken to 4 groups:
+~~~
+'dev', 'database', 'staging', 1
+~~~
+
+This regex is used for all the host names and should be designed accordingly.
+
+The idea behind the regex is to enable sorting and grouping of hosts from regex
+groups extracted from host names. Those groups are used to crate meaningful
+layouts. I know, sounds more complex than it really is...
+
+* * *
+__'reject-regex'__ (optional) field is used to ignore some hosts while starting
+a session.
+
+* * *
+Fields (__'regex-parts-to'__) __'group-by'__ and __'sort-by'__ are referencing
+before mentioned __'regex'__ field. As their names suggest, they decide which
+servers constitute a group (and share layout and potentially commands) and how
+to sort
+serves in a group. Both fields can reference more than one regex group.
+
+In the above example, for 'dev.database-staging-1' host name, a group to which
+the host belongs would be 2nd group, which is: 'database'.
+
+* * *
+(optional) field __'name'__ and it's (optional) subfields
+__'regex-ignore-parts'__, __'separator'__ and __'prefix'__ decide how to name
+the servers. If those fields are omitted, ssh host name is used instead.
+
+Filed __'regex-ignore-parts'__ potentially removes some regex groups from name,
+__'separator'__ is used to separate left-over groups and it's possible to
+specify __'prefix'__ for the name.
+
+* * *
+(optional) field __'merge-groups'__ contains groups that should be merged (for
+layout purposes) together. This can be used to group a few servers that are
+unique in type or small in numbers. E.g. grouping different DB servers.
+
+~~~
+lbs: ['haproxy', 'nginx']
+~~~
+In this example two different kinds of loadbalancers are grouped together.
+
+Note that the servers from merge groups can later be referenced with both
+original and merge-group name.
+
+* * *
+Finally, what's left is the layout definition:
+
+There are 2 main ways to specify a layout for a (merge-)group:
+
+1. built-in tmux layouts (even-horizontal, even-vertical, main-horizontal,
+main-vertical or tiled)
+    - defines a tmux layout and (optionally) maximum number of panes in one
+        window (default 9).
+2. custom tiled layout
+    -  defines filed layout with maximal size of rows and columns. There is
+        also an (optional) option to specify if the panes flow from left to
+        right (horizontal - default) or from top to bottom (vertical)
+
+The layouts are applied individually to any merge group and to any normal
+(regex) group not belonging to some merge group. If there are more servers in
+a group then layout allows on a single window, next window for that group is
+added. Servers from different groups never share a window.
+
+
+## Requirements
+To be able to use the gem you should have ruby 1.9+ and tmux installed on a *nix
+(Mac OS X, Linux, ...) machine. (Windows: here be dragons)
+
+Interaction with tmux is done via bash commands.
+
+Minimal familiarity with tmux is required.
+For a start, switching between panes/windows and attaching/detaching is enough:
+
+* detach session: `<prefix>d`
+* attach session: `tmux attach -t <session-name>`
+* navigate windows (next/previous): `<prefix>n` & `<prefix>p`
+* navigate panes: `<prefix><arrow>`
+
+(prefix is by default `C-b`)
+
+
+## Installation
+
+The gem provides CLI and currently it is not intended to be used as part of
+bigger ruby apps.
+
+Install it with:
+~~~
+$ gem install tmux-connector
+~~~
+
+
+#### Installing tmux
+
+If tmux isn't already installed, install it using your favorite mathod,
+e.g.:
+* Linux: `apt-get install tmux`
+* Mac OS X: `brew install tmux`
+
+
+## Tips
+
+###  SSH config files
+
+If you plan on specifying separate ssh config file when starting session,
+consider adding the following lines on top:
+~~~
+StrictHostKeyChecking no
+UserKnownHostsFile=/dev/null
+~~~
+
+That way you won't have problems with known hosts changes or with infinite
+questions to approve new hosts. Do this _only_ if you understand security
+consequences and are sure that it is safe to do so.
+
+
+### Tmux configuration
+
+Since gem uses tmux, consider configuring it for your purposes. E.g. I'm a [Vim]
+user, and so configure tmux to use Vim-like bindings to switch panes. For more
+information, check my [dotfiles].
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+Or just mail me, mail: << username >>@gmail.com
+
+This is my first real gem, so all your comments are more than welcome.
+I'd really appreciate ruby code improvements/refactoring comments or usability
+comments (all other are welcome too). Just _drop me a line_. :)
+
+
+## Comments, ideas or if you feel like chatting
+
+Take a look at `TODO.md` file (in the repository) for ideas about additional
+features in new versions.
+
+<< username >>@gmail.com
+
+I'd be happy to hear from you.
+
+
+[docopt]: https://github.com/docopt/docopt
+[tmux]: http://en.wikipedia.org/wiki/Tmux
+[CLI]: http://en.wikipedia.org/wiki/Command-line_interface
+[Vim]: http://www.vim.org/
+[dotfiles]: https://github.com/ikusalic/dotfiles
+[YAML]: http://en.wikipedia.org/wiki/YAML
+[rubulator]: http://rubular.com/

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/TODO.md

@@ -0,0 +1,12 @@
+possible features for new version:
+    * ensure it works with zsh
+    * generate default config via just regex(es)
+    * add strict config file validation
+    * add window (via option) that won't connect to nay server
+        - for tcon commands and regular actions on local machine
+    * startup command
+
+code related:
+    * add specs
+    * test with ruby 2.0
+    * refactoring

data/bin/tcon

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/tmux-connector'
+
+TmuxConnector.main ARGV

data/lib/tmux-connector/command_handler.rb

@@ -0,0 +1,27 @@
+require_relative 'commands/delete'
+require_relative 'commands/list'
+require_relative 'commands/resume'
+require_relative 'commands/send'
+require_relative 'commands/start'
+
+
+module TmuxConnector
+  COMMANDS = %w[ start resume delete list send ]
+
+  def self.process_command(args)
+    command = detect_command args
+    klass = get_class command
+    command_obj = klass.new args
+    command_obj.run
+  end
+
+  def self.detect_command(args)
+    COMMANDS.each { |e| return e if args[e] }
+    raise 'unkonwn command'
+  end
+
+  def self.get_class(command)
+    class_name = command.split('-').map { |e| e.capitalize }.join
+    return TmuxConnector.const_get class_name
+  end
+end

data/lib/tmux-connector/commands/delete.rb

@@ -0,0 +1,24 @@
+require_relative '../persistence_handler'
+
+
+module TmuxConnector
+  class Delete
+    attr_reader :delete_all
+    attr_reader :name
+
+    def initialize(args)
+      @name = args['<session-name>']
+      @delete_all = args['--all']
+    end
+
+    def run()
+      if name
+        TmuxConnector.delete_session name
+        TmuxConnector.delete_tmux_session name
+      elsif delete_all
+        TmuxConnector.delete_all
+        TmuxConnector.delete_all_tmux_sessions
+      end
+    end
+  end
+end

data/lib/tmux-connector/commands/list.rb

@@ -0,0 +1,16 @@
+require_relative '../persistence_handler'
+
+
+module TmuxConnector
+  class List
+    def initialize(args)
+    end
+
+    def run()
+      sessions_data = TmuxConnector.list_sessions
+      puts "sessions:"
+      puts sessions_data.to_yaml
+      puts "-" * 20
+    end
+  end
+end

data/lib/tmux-connector/commands/resume.rb

@@ -0,0 +1,17 @@
+require_relative '../session'
+
+
+module TmuxConnector
+  class Resume
+    attr_reader :name
+    attr_reader :session
+
+    def initialize(args)
+      @session = Session.load_by_name args['<session-name>']
+    end
+
+    def run()
+      session.start
+    end
+  end
+end

data/lib/tmux-connector/commands/send.rb

@@ -0,0 +1,42 @@
+require_relative '../session'
+require_relative '../tmux_handler'
+
+
+module TmuxConnector
+  class Send
+    attr_reader :commands
+    attr_reader :group_filter
+    attr_reader :name
+    attr_reader :server_filter
+    attr_reader :session
+    attr_reader :verbose
+
+    def initialize(args)
+      @name = args['<session-name>']
+      @verbose = args['--verbose']
+
+      load_commands args
+
+      @server_filter = Regexp.new(args['--server-filter']) rescue nil
+      @group_filter = Regexp.new(args['--group-filter']) rescue nil
+
+      @session = Session.load_by_name args['<session-name>']
+    end
+
+    def run()
+      session.tmux_session.send_commands(commands, server_filter, group_filter, verbose)
+    end
+
+  private
+      
+      def load_commands(args)
+        if args['<command>']
+          @commands = args['<command>']
+        else
+          file = File.expand_path args['--command-file']
+          raise "command file (#{ file }) not found" unless File.exist? file
+          @commands = open(file) { |f| f.read }
+        end
+      end
+  end
+end

data/lib/tmux-connector/commands/start.rb

@@ -0,0 +1,65 @@
+require_relative '../config_handler'
+require_relative '../host'
+require_relative '../session'
+require_relative '../ssh_config_parser'
+
+
+module TmuxConnector
+  class Start
+    attr_reader :config
+    attr_reader :hosts
+    attr_reader :groups
+    attr_reader :merge_rules
+    attr_reader :session
+
+    def initialize(args)
+      @config = TmuxConnector.get_config args['<config-file>']
+
+      ssh_hostnames = SSHConfig.get_hosts(args['--ssh-config'], config['reject-regex'])
+      @hosts = ssh_hostnames.reduce([]) do |acc, name|
+        ( acc << Host.new(name, config) ) rescue nil
+        acc
+      end
+
+      generate_groups
+      generate_merge_rules
+
+      @session = Session.new config, args, groups, merge_rules
+    end
+
+    def run()
+      session.save
+      session.start
+    end
+
+  private
+
+      def generate_groups()
+        @groups = hosts.reduce({}) do |acc, e|
+          acc[e.group_id] ||= []
+          acc[e.group_id] << e
+          acc
+        end
+        sort_groups!
+      end
+
+      def generate_merge_rules()
+        @merge_rules = {}
+        config['merge-groups'].each do |name, elements|
+          elements.each { |e| @merge_rules[e] = name }
+        end
+        @groups.keys.each { |e| @merge_rules[e] ||= e }
+      end
+
+      def sort_groups!()
+        @groups.each do |k, v|
+          numbers_only = v.all? { |e| e.sort_value =~ /^[-+]?[0-9]+$/ }
+          if numbers_only
+            v.sort! { |a, b| a.sort_value.to_i <=> b.sort_value.to_i }
+          else
+            v.sort_by!(&:sort_value)
+          end
+        end
+      end
+  end
+end

data/lib/tmux-connector/config_handler.rb

@@ -0,0 +1,47 @@
+require 'yaml'
+
+
+module TmuxConnector
+  DEFAULT_CONFIG_FILE = 'lib/tmux-connector/default_config.yml'
+
+  def self.get_config(config_file)
+    config = read_config config_file
+    process_config! config
+    validate_config config
+    return config
+  end
+
+  def self.read_config(config_file)
+    full_path = File.expand_path config_file
+    raise "configuration file (#{config_file}) not found" unless File.exist? full_path
+    config = YAML.load_file full_path
+
+    return config
+  end
+
+  def self.process_config!(config)
+    config['regex'] = Regexp.new config['regex']
+    config['reject-regex'] = Regexp.new config['reject-regex'] if config['reject-regex']
+    if config['name']
+      c = config['name']
+      c['regex-ignore-parts'] ||= []
+      c['separator'] ||= '-'
+      c['prefix'] ||= ''
+    end
+
+    process_layout config['layout']['default']
+    config['layout']['group-layouts'].each { |k, v| process_layout v }
+  end
+
+  def self.process_layout(config)
+    if config['tmux']
+      config['tmux']['max-panes'] ||= 9
+    else
+      config['custom']['panes-flow'] ||= 'horizontal'
+    end
+  end
+
+  def self.validate_config(config)
+    # TODO
+  end
+end

data/lib/tmux-connector/host.rb

@@ -0,0 +1,36 @@
+module TmuxConnector
+  class Host
+    attr_reader :ssh_name
+    attr_reader :display_name
+    attr_reader :group_id
+    attr_reader :sort_value
+
+    def initialize(name, config)
+      @ssh_name = name
+
+      groups = name.match(config['regex'])[1..-1]
+      @display_name = create_display_name groups, config
+      @sort_value = config['regex-parts-to']['sort-by'].map { |i| groups[i] }.join '-'
+      @group_id = config['regex-parts-to']['group-by'].map { |i| groups[i] }.join '-'
+    end
+
+    def to_s()
+      return "<host::#{ display_name }>"
+    end
+
+  private
+
+      def create_display_name groups, config
+        if config['name']
+          parts = []
+          groups.each_with_index do |e, i|
+            parts << e unless config['name']['regex-ignore-parts'].include? i
+          end
+
+          return config['name']['prefix'] + parts.join(config['name']['separator'])
+        end
+
+        return @ssh_name
+      end
+  end
+end

data/lib/tmux-connector/layout.rb

@@ -0,0 +1,71 @@
+module TmuxConnector
+  class Layout
+    attr_reader :groups
+    attr_reader :merge_rules
+    attr_reader :merged_groups
+    attr_reader :raw_config
+    attr_reader :windows
+
+    def initialize(config, groups, merge_rules)
+      @raw_config = config
+      @groups = groups
+      @merge_rules = merge_rules
+
+      @windows = []
+
+      generate
+    end
+
+  private
+
+      def generate()
+        config = process_layout_config
+
+        @merged_groups = {}
+        merge_rules.each do |k, v|
+          raise "group '#{ k }' not found" if groups[k].nil?
+          @merged_groups[v] ||= []
+          @merged_groups[v].concat groups[k]
+        end
+
+        merged_groups.each do |name, hosts|
+          add_group_to_layout name, hosts, (config[name] || config['default'])
+        end
+      end
+
+      def process_layout_config()
+        { 'default' => raw_config['default'] }.merge raw_config['group-layouts']
+      end
+
+      def add_group_to_layout(group_name, hosts, config)
+        if config['custom']
+          n = config['custom']['max-horizontal'] * config['custom']['max-vertical']
+        else
+          n = config['tmux']['max-panes']
+        end
+
+        hosts.each_slice(n).with_index do |arr, i|
+          window = {
+            name: "#{ group_name }##{ i + 1 }",
+            group_name: group_name,
+            group_index: i + 1
+          }
+
+          if config['tmux']
+            window[:tmux] = config['tmux']['layout']
+            window[:panes] = arr
+          else
+            window[:flow] = config['custom']['panes-flow']
+
+            if window[:flow] == 'horizontal'
+              window[:panes] = arr.each_slice(config['custom']['max-horizontal']).to_a
+            else
+              window[:panes] = arr.each_slice(config['custom']['max-vertical']).to_a
+            end
+          end
+
+          windows << window
+        end
+      end
+  end
+end

data/lib/tmux-connector/persistence_handler.rb

@@ -0,0 +1,101 @@
+require 'fileutils'
+
+
+module TmuxConnector
+  BASE_DIR = File.expand_path '~/.tmux-connector'
+  MAIN_FILE = File.join BASE_DIR, '_sessions.yml'
+  SESSION_BASE_NAME = "s#"
+
+  def self.save_session(session_name, session_obj)
+    prepare_if_necessary
+
+    created = Time.now.strftime('%Y-%m-%d %H:%M')
+
+    file = File.join(BASE_DIR, "#{ session_name.gsub(/[^a-zA-Z0-9_-]+/, '-') }.bin")
+    file.sub!('.bin', "__#{ created.gsub(/[ :]/, '_') }.bin") if File.exists? file
+
+    update_main_file(session_name, created, file, session_obj.args['--purpose'])
+
+    open(file, 'wb') { |f| Marshal.dump session_obj, f }
+  end
+
+  def self.load_session(session_name)
+    data = list_sessions
+    raise "session not found: '#{ session_name }'" if data[session_name].nil?
+
+    file = data[session_name]['file']
+    raise "session file (#{ file }) not found" unless File.exist? file
+
+    session = nil
+    open(file, 'rb') { |f| session = Marshal.load f }
+    return session
+  end
+
+  def self.prepare_if_necessary()
+    unless File.exists?(BASE_DIR) && File.directory?(BASE_DIR)
+      Dir.mkdir(BASE_DIR)
+    end
+
+    FileUtils.touch MAIN_FILE unless File.exists? MAIN_FILE
+  end
+
+  def self.delete_all()
+    FileUtils.rm_rf BASE_DIR
+  end
+
+  def self.update_main_file(session_name, created, file, purpose)
+    data = list_sessions
+
+    data[session_name] = {
+      'created' => created,
+      'file' => file
+    }
+    data[session_name]['purpose'] = purpose if purpose
+
+    open(MAIN_FILE, 'w') { |f| f.write data.to_yaml }
+
+    return file
+  end
+
+  def self.delete_session(session_name)
+    data = list_sessions
+    raise "session not found: '#{ session_name }'" if data[session_name].nil?
+
+    file = data[session_name]['file']
+    data.delete session_name
+    open(MAIN_FILE, 'w') { |f| f.write data.to_yaml }
+    File.delete(file) rescue nil
+
+  end
+
+  def self.list_sessions()
+    raise "session file (#{ MAIN_FILE }) not found" unless File.exist? MAIN_FILE
+    return ( YAML.load_file(MAIN_FILE) rescue {} ) || {}
+  end
+
+  def self.get_new_session_name(args)
+    specified = args["--session-name"]
+
+    if File.exists? MAIN_FILE
+      existing_names = list_sessions.keys
+
+      if specified
+        raise "session with name '#{ specified }' already exists." if existing_names.include? specified
+        name = specified
+      else
+        re = /#{ SESSION_BASE_NAME }(\d+)/
+
+        last_index = existing_names.reduce(0) do |acc, e|
+          index = ( e.match(re)[1].to_i rescue 0 )
+          [ acc, index].max
+        end
+
+        name = "#{ SESSION_BASE_NAME }#{ last_index + 1 }"
+      end
+    else
+      name = specified || "#{ SESSION_BASE_NAME }1"
+    end
+
+    return name
+  end
+end

data/lib/tmux-connector/session.rb

@@ -0,0 +1,38 @@
+require_relative 'layout'
+require_relative 'persistence_handler'
+require_relative 'tmux_handler'
+
+
+module TmuxConnector
+  class Session
+    def self.load_by_name(name)
+      return TmuxConnector.load_session name
+    end
+
+    attr_reader :args
+    attr_reader :config
+    attr_reader :name
+    attr_reader :merge_rules
+    attr_reader :tmux_session
+    attr_reader :windows
+
+    def initialize(config, args, groups, merge_rules)
+      @config = config
+      @args = args
+      @merge_rules = merge_rules
+
+      @name = TmuxConnector.get_new_session_name(args)
+      @windows = Layout.new(config['layout'], groups, merge_rules).windows
+
+      @tmux_session = TmuxSession.new self
+    end
+
+    def start()
+      tmux_session.start_session
+    end
+
+    def save()
+      TmuxConnector.save_session name, self
+    end
+  end
+end

data/lib/tmux-connector/ssh_config_parser.rb

@@ -0,0 +1,15 @@
+module SSHConfig
+  HOST_REGEX = /^Host (.+)$/
+
+  def self.get_hosts(config_file, reject_re=nil)
+    hosts = read_config(config_file).scan(HOST_REGEX).map(&:first).map(&:strip)
+    hosts.reject! { |e| e.match reject_re } if reject_re
+    return hosts
+  end
+
+  def self.read_config(config_file)
+    full_path = File.expand_path config_file
+    raise "ssh config file (#{config_file}) not found" unless File.exist? full_path
+    return open(full_path).read
+  end
+end

data/lib/tmux-connector/tmux_handler.rb

@@ -0,0 +1,173 @@
+module TmuxConnector
+  def self.delete_tmux_session(name)
+    system "tmux kill-session -t #{ name } &> /dev/null"
+  end
+
+  def self.delete_all_tmux_sessions()
+    sessions_list = %x( tmux list-sessions &> /dev/null )
+    sessions = sessions_list.scan(/^([^:]+): /).map(&:first)
+    sessions.each { |e| delete_tmux_session e }
+  end
+
+
+  class TmuxSession
+    attr_reader :name
+    attr_reader :session
+    attr_accessor :commands
+
+    def initialize(session)
+      @session = session
+
+      @name = session.name
+      @commands = []
+    end
+
+    def start_session()
+      create_session
+      create_windows
+      create_panes
+      clear_panes
+
+      connect
+
+      attach_to_session
+
+      execute
+    end
+
+    def send_commands(send_commands, server_regex, group_regex, verbose)
+      count = 0
+      each_pane do |window_index, pane_index, host|
+        if( (server_regex.nil? || host.ssh_name.match(server_regex)) &&
+            (group_regex.nil? || host.group_id.match(group_regex) ||
+              session.merge_rules[host.group_id].match(group_regex)) )
+          system("tmux send-keys -t #{ name }:#{ window_index }.#{ pane_index } '#{ send_commands }' C-m")
+          count += 1
+        end
+      end
+
+      puts "command sent to #{ count } server[s]" if verbose
+    end
+
+  private
+
+      def execute()
+        commands.each { |e| system e }
+      end
+
+      def create_session()
+        commands << <<HERE
+tmux start-server
+
+tmux has-session -t #{ name } &> /dev/null
+[ $? -eq 0 ] && tmux kill-session -t #{ name }
+
+tmux new-session -s #{ name } -n RENAME -d
+HERE
+      end
+
+      def create_windows()
+        session.windows.each_with_index do |w, i|
+          if i == 0
+            commands << "tmux rename-window -t #{ name }:0 #{ w[:name] }"
+          else
+            commands << "tmux new-window -t #{ name }:#{ i } -n #{ w[:name] }"
+          end
+        end
+      end
+
+      def create_panes()
+        session.windows.each_with_index do |w, wi|
+          commands << "tmux select-window -t #{ name }:0"
+          if w[:tmux]
+            w[:panes].each_with_index do |p, pi|
+              # size is specified so panes are not to small and cause errors
+              size = (100.0 * (w[:panes].size - pi - 1) / (w[:panes].size - pi)).round
+
+              commands << "tmux split-window -p #{ size } -t #{ name }:#{ wi }" unless pi == 0
+              commands << tmux_set_title_cmd(p.display_name, wi, pi)
+            end
+
+            commands << "tmux select-layout -t #{ name }:#{ wi } #{ w[:tmux] } &> /dev/null"
+          else
+            create_custom_layout w, wi
+          end
+
+          commands << "tmux select-pane -t #{ name }:#{ wi }.0"
+        end
+      end
+
+      def clear_panes()
+        each_pane do |window_index, pane_index|
+          commands << "tmux send-keys -t #{ name }:#{ window_index }.#{ pane_index } clear C-m"
+        end
+      end
+
+      def connect()
+        ssh_config_path = File.expand_path session.args['--ssh-config']
+
+        each_pane do |window_index, pane_index, host|
+          ssh_command = "ssh -F #{ ssh_config_path } #{ host.ssh_name }"
+          commands << "tmux send-keys -t #{ name }:#{ window_index }.#{ pane_index } '#{ ssh_command }' C-m"
+        end
+      end
+
+      def attach_to_session()
+        commands << <<HERE
+tmux select-pane -t #{ name }:0.0
+tmux select-window -t #{ name }:0
+tmux attach -t #{ name }
+HERE
+      end
+
+      def each_pane(&block)
+        session.windows.each_with_index do |window, window_index|
+          if window[:tmux]
+            window[:panes].each_with_index do |host, pane_index|
+              yield(window_index, pane_index, host)
+            end
+          else
+            pane_index = 0
+            window[:panes].each do |g|
+              g.each do |host|
+                yield(window_index, pane_index, host)
+                pane_index += 1
+              end
+            end
+          end
+        end
+      end
+
+      def create_custom_layout(window, window_index)
+        direction = (window[:flow] == 'horizontal') ? ['-h', '-v'] : ['-v', '-h']
+
+        pane_index = 0
+        window[:panes].each_with_index do |group, group_index|
+          commands << "tmux select-pane -t #{ name }:#{ window_index }.#{ pane_index }"
+
+          # create pane in a next row ahead of time so pane indexes match hosts
+          if group_index < window[:panes].size - 1
+            size = (100.0 * (window[:panes].size - group_index - 1) / (window[:panes].size - group_index)).round
+            commands << "tmux split-window #{ direction[1] } -p #{ size } -t #{ name }:#{ window_index }"
+            display_name = window[:panes][group_index + 1][0].display_name
+            commands << tmux_set_title_cmd(display_name, window_index, -1)
+            commands << "tmux select-pane -t #{ name }:#{ window_index }.#{ pane_index }"
+          end
+
+          group.each_with_index do |host, host_index|
+            size = (100.0 * (group.size - host_index) / (group.size - host_index + 1)).round
+            commands << "tmux split-window #{ direction[0] } -p #{ size } -t #{ name }:#{ window_index }" unless host_index == 0
+            commands << tmux_set_title_cmd(host.display_name, window_index, pane_index)
+
+            pane_index += 1
+          end
+        end
+      end
+
+      def tmux_set_title_cmd(title, window_id, pane_id)  # pane_id == -1 -> do not specify
+        keys = %q|printf '\033]2;%s\033\\'| + " '#{ title }'"
+        pane_id_str = (pane_id == -1) ? '' : ".#{ pane_id }"
+        return %Q|tmux send-keys -t #{ name }:#{ window_id }#{ pane_id_str } "#{ keys }" C-m|
+      end
+  end
+end

data/lib/tmux-connector/version.rb

@@ -0,0 +1,3 @@
+module TmuxConnector
+  VERSION = "0.0.2"
+end

data/lib/tmux-connector.rb

@@ -0,0 +1,56 @@
+require 'docopt'
+
+require_relative 'tmux-connector/version'
+require_relative 'tmux-connector/command_handler'
+
+
+module TmuxConnector
+  TCON_DOC = <<HERE
+tcon enables establishing connections (ssh) to multiple servers and executing
+commands on those servers. The sessions can be persisted (actually recreated)
+even after computer restarts. Complex sessions with different layouts for
+different kinds of servers can be easily created.
+
+Usage:
+  tcon start <config-file> [--ssh-config=<file>]
+             [--session-name=<name>] [--purpose=<description>]
+  tcon resume <session-name>
+  tcon delete (<session-name> | --all)
+  tcon list
+  tcon send <session-name> (<command> | --command-file=<file>)
+            [--server-filter=<regex>] [--group-filter=<regex>] [--verbose]
+  tcon --help
+  tcon --version
+
+Options:
+  <config-file>              Path to configuration file. Configuration file
+                             describes how new session is started. YAML format.
+  <session-name>             Name that identifies the session. Must be unique.
+  <command>                  Command to be executed on remote server[s].
+  -s --ssh-config=file       Path to ssh config file [default: ~/.ssh/config].
+  -n --session-name=name     Name of the session to be used in the tcon command.
+  -p --purpose=description   Description of session's purpose.
+  --all                      Delete all existing sessions.
+  -f --server-filter=regex   Filter to select a subset of the servers.
+                             Should be valid ruby regex.
+  -g --group-filter=regex    Filter to select a subset of the servers via
+                             group membership.  Should be valid ruby regex.
+  -c --command-file=file     File containing the list of commands to be
+                             executed on remote server[s].
+  -v --verbose               Report how many servers were affected by the send
+                             command.
+  -h --help                  Show this screen.
+  --version                  Show version.
+HERE
+
+  def self.main(input_args)
+    begin
+      args = Docopt.docopt TCON_DOC, argv: input_args, version: VERSION
+      process_command args
+    rescue Docopt::Exit => e
+      puts e.message
+    rescue => e
+      puts "Something went wrong: #{ e.message }"
+    end
+  end
+end

data/tmux-connector.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'tmux-connector/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "tmux-connector"
+  gem.version       = TmuxConnector::VERSION
+  gem.authors       = ["Ivan Kusalic"]
+  gem.email         = ["ikusalic@gmail.com"]  # TODO
+  gem.summary       = %q{Manage multiple servers using SSH and tmux.}
+  gem.description   = %q{tcon enables establishing connections (ssh) to multiple servers and executing commands on those servers. The sessions can be persisted (actually recreated) even after computer restarts. Complex sessions with different layouts for different kinds of servers can be easily created.} 
+  gem.homepage      = "http://github.com/ikusalic"  # TODO
+
+  gem.add_dependency('docopt')
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: tmux-connector
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Ivan Kusalic
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: docopt
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: tcon enables establishing connections (ssh) to multiple servers and executing
+  commands on those servers. The sessions can be persisted (actually recreated) even
+  after computer restarts. Complex sessions with different layouts for different kinds
+  of servers can be easily created.
+email:
+- ikusalic@gmail.com
+executables:
+- tcon
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- TODO.md
+- bin/tcon
+- lib/tmux-connector.rb
+- lib/tmux-connector/command_handler.rb
+- lib/tmux-connector/commands/delete.rb
+- lib/tmux-connector/commands/list.rb
+- lib/tmux-connector/commands/resume.rb
+- lib/tmux-connector/commands/send.rb
+- lib/tmux-connector/commands/start.rb
+- lib/tmux-connector/config_handler.rb
+- lib/tmux-connector/host.rb
+- lib/tmux-connector/layout.rb
+- lib/tmux-connector/persistence_handler.rb
+- lib/tmux-connector/session.rb
+- lib/tmux-connector/ssh_config_parser.rb
+- lib/tmux-connector/tmux_handler.rb
+- lib/tmux-connector/version.rb
+- tmux-connector.gemspec
+homepage: http://github.com/ikusalic
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Manage multiple servers using SSH and tmux.
+test_files: []