canals 0.8.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b0af6d8d1f776054496a2e57bd383087ceb9d847
+  data.tar.gz: 84eef80c5fc95a038bb58361ecbe6a80676a1f8b
+SHA512:
+  metadata.gz: 068e49ef7a7a43c035e9d6c4ee8815ad9a985639b5e0b50d290f52e4afb30a0c7531babd8ab7aa8d8a6ff1ac3ef11df3314209657f626518cb5128f5542b3e01
+  data.tar.gz: 3add6233e74d5debf21966b693f3c362fe660b25a13eaadff67ce8d4e51b74c676ecff8b84720979b92142aaca66a14caca615d6f3bed3205b86caeafd805df3

data/.gitignore

@@ -0,0 +1,38 @@
+/pkg
+.idea/*
+*.iml
+*.swp
+*.DS_Store
+
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+Gemfile.lock
+# .ruby-version
+# .ruby-gemset

data/.rvmrc

@@ -0,0 +1 @@
+rvm use ruby@canals --create

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+group :development do
+  gem 'rake'
+  gem 'pry'
+end
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Ido Abramovich
+
+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,11 @@
+# Canals: Help manage SSH tunnels
+
+Canals eases the process of creating and managing SSH tunnels.
+Behind the scenes, Canals creates SSH tunnels using the standard OpenSSH library, but it helps with making the process more forward and by remembering those tunnels between usages.
+
+### Instalation
+
+```
+gem install canals
+canal setup wizard
+```

data/Rakefile

@@ -0,0 +1,3 @@
+require 'bundler'
+
+Bundler::GemHelper.install_tasks

data/assets/canals.sh

@@ -0,0 +1,53 @@
+#!/bin/bash
+
+_canal_complete() {
+  local cur prev
+
+  COMPREPLY=()
+  cur=${COMP_WORDS[COMP_CWORD]}
+  prev=${COMP_WORDS[COMP_CWORD-1]}
+
+  # Setup the base level (everything after "canal")
+  if [ $COMP_CWORD -eq 1 ]; then
+    COMPREPLY=( $(compgen \
+                  -W "create environment help repo restart session setup start stop" \
+                  -- $cur) )
+    return 0
+  fi
+
+  # Setup the second level
+  if [ $COMP_CWORD -eq 2 ]; then
+    case "$prev" in
+      start|stop|restart)
+        COMPREPLY=( $(compgen \
+                      -W "`canal list tunnels`" \
+                      -- $cur) )
+        ;;
+      environment)
+        COMPREPLY=( $(compgen \
+                      -W "create help show" \
+                      -- $cur) )
+        ;;
+      session)
+        COMPREPLY=( $(compgen \
+                      -W "help restart restore show stop" \
+                      -- $cur) )
+        ;;
+      setup)
+        COMPREPLY=( $(compgen \
+                      -W "completion help wizard" \
+                      -- $cur) )
+        ;;
+      # Everything else
+      *)
+        COMPREPLY=( $(compgen \
+                      -W "`canal list commands $prev`" \
+                      -- $cur) )
+        ;;
+    esac
+    return 0
+  fi
+
+  return 0
+}
+complete -F _canal_complete canal

data/bin/canal

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+Signal.trap('INT') { exit 1 }
+
+# resolve bin path, ignoring symlinks
+require 'pathname'
+bin_file = Pathname.new(__FILE__).realpath
+
+# add self to libpath
+$LOAD_PATH.unshift File.expand_path("../../lib", bin_file)
+
+require "canals/cli"
+
+Canals::Cli::Application.start(ARGV)

data/canals.gemspec

@@ -0,0 +1,27 @@
+$:.push File.expand_path('../lib', __FILE__)
+require 'canals/version'
+
+Gem::Specification.new do |s|
+  s.name                  = "canals"
+  s.version               = Canals::VERSION
+  s.platform              = Gem::Platform::RUBY
+
+  s.summary               = "Eases the process of creating and managing SSH tunnels"
+  s.description           = "A console utility to help build ssh tunnels and keep them up"
+  s.authors               = ["Ido Abramovich"]
+  s.email                 = "canals.sf17@abramovich.info"
+  s.homepage              = 'http://github.com/idoa01/canals'
+
+  s.required_ruby_version = '>= 2.2.0'
+  s.rubyforge_project     = "canals"
+  s.files                 = `git ls-files`.split($/)
+  s.test_files            = `git ls-files -- {test,spec,features}/*`.split($/)
+  s.executables           = `git ls-files -- bin/*`.split($/).map{ |f| File.basename(f) }
+  s.require_path          = "lib"
+  s.license               = "MIT"
+
+  s.add_dependency        'thor', '~> 0.19.1'
+  s.add_dependency        'terminal-table', '~> 1.5'
+
+  s.add_development_dependency 'rspec', '~> 3.4'
+end

data/lib/canals/cli/environment.rb

@@ -0,0 +1,44 @@
+require 'canals'
+require 'canals/options'
+require 'canals/environment'
+require 'thor'
+
+
+module Canals
+  module Cli
+    class Environment < Thor
+      include Thor::Actions
+
+      desc 'create NAME HOSTNAME', 'Create a new ssh environment'
+      method_option :user,    :type => :string,  :desc => "The user for the ssh proxy host"
+      method_option :pem,     :type => :string,  :desc => "The PEM file location for this environment"
+      method_option :default, :type => :boolean, :desc => "Make this the default enviroment"
+      def create(name, hostname)
+        user, host = hostname.split("@")
+        if host.nil?
+          host = hostname
+          user = nil
+        end
+        opts = {"name" => name, "hostname" => host}.merge(options)
+        opts["user"] = user if !user.nil?
+        env = Canals::Environment.new(opts)
+        Canals.repository.add_environment(env)
+      end
+
+      desc "show [ENV]", "Show the available tunnels"
+      def show(env=nil)
+        if Canals.environments.empty?
+          say "No environments currently defined."
+          return
+        end
+        require 'terminal-table'
+        rows = Canals.environments.select{ |e| env.nil? || e.name == env}.map{ |e| [(e.is_default? ? "*" : ""), e.name, e.user, e.hostname, e.pem] }
+        table = Terminal::Table.new :headings => ['', 'Name', 'User', 'Hostname', 'PEM'], :rows => rows
+        say table
+      end
+
+      default_task :show
+    end
+  end
+end
+

data/lib/canals/cli/helpers.rb

@@ -0,0 +1,38 @@
+require 'canals'
+require 'canals/tools/completion'
+
+module Canals
+  module Cli
+    module Helpers
+
+      def tstop(name)
+        Canals.stop(name)
+        say "Tunnel #{name.inspect} stopped."
+      end
+
+      def tstart(name)
+        pid = Canals.start(name)
+        say "Created tunnel #{name.inspect} with pid #{pid}"
+        pid
+      end
+
+      def trestart(name)
+        tstop(name)
+        tstart(name)
+      end
+
+      def startup_checks
+        check_completion
+      end
+
+      def check_completion
+        if Canals.config[:completion_version]
+          if Canals.config[:completion_version] != Canals::VERSION
+            Canals::Tools::Completion.update_completion
+            say "bash completion script upgraded, use `source #{Canals::Tools::Completion.cmp_file}` to reload it", :red
+          end
+        end
+      end
+    end
+  end
+end

data/lib/canals/cli/list.rb

@@ -0,0 +1,43 @@
+require 'canals'
+require 'canals/options'
+require 'canals/environment'
+require 'thor'
+require 'pry'
+
+module Canals
+  module Cli
+    class List < Thor
+      include Thor::Actions
+
+      desc 'environments', 'List the different environments'
+      def environments
+        envs = Canals.environments.map{ |conf| conf.name }
+        say envs.sort.join " "
+      end
+
+      desc 'tunnels', 'List the different tunnels'
+      def tunnels
+        tunnels = Canals.repository.map{ |conf| conf.name }
+        say tunnels.sort.join " "
+      end
+
+      desc 'commands', 'List all the base level commands'
+      def commands(subcommand=nil)
+        #binding.pry
+        thor_class = Canals::Cli::Application
+        if !subcommand.nil?
+          thor_class = thor_class.subcommand_classes[subcommand]
+          if thor_class.nil?
+            return
+          end
+        end
+
+        cmds = thor_class.all_commands.values.select{ |c| c.class == Thor::Command }.map{ |c| c.name }
+        say cmds.sort.join " "
+      end
+
+    end
+  end
+end
+
+

data/lib/canals/cli/session.rb

@@ -0,0 +1,75 @@
+require 'canals'
+require 'canals/cli/helpers'
+require 'thor'
+
+
+module Canals
+  module Cli
+    class Session < Thor
+      include Thor::Actions
+      include Canals::Cli::Helpers
+
+      desc "show", "Show the current session"
+      def show
+        return if session_empty?
+        require 'terminal-table'
+        require 'canals/core_ext/string'
+        columns = ["pid", "name", "socket"]
+        rows = Canals.session.map{ |s| columns.map{ |c| s[c.to_sym] } }
+        table = Terminal::Table.new :headings => columns.map{|c| c.sub("_"," ").titleize }, :rows => rows
+        say table
+      end
+
+      desc "restore", "Restore the connection to tunnels which aren't working"
+      def restore
+        on_all_canals_in_session(:restore) do |name|
+          if Canals.isalive? name
+            say "Canal #{name.inspect} is running."
+          else
+            Canals.session.del(name)
+            tstart(name)
+          end
+        end
+      end
+
+      desc "restart", "Restart the current session (closing and starting all connections)"
+      def restart
+        on_all_canals_in_session(:restart) do |name|
+          trestart(name)
+        end
+      end
+
+      desc "stop", "Stop the current session"
+      def stop
+        on_all_canals_in_session(:stop) do |name|
+          tstop(name)
+        end
+      end
+
+      no_commands do
+        def on_all_canals_in_session(command, &block)
+          return if session_empty?
+          Canals.session.map{|s| s[:name]}.each do |name|
+            say "#{command.to_s.capitalize} canal #{name.inspect}:", :green
+            block.call(name)
+          end
+          say
+          say "#{command} done.", :green
+        end
+
+        def session_empty?
+          if Canals.session.empty?
+            say "Canal session is currently empty."
+            true
+          else
+            false
+          end
+        end
+      end
+
+      default_task :show
+    end
+  end
+end
+
+

data/lib/canals/cli/setup.rb

@@ -0,0 +1,98 @@
+require 'canals'
+require 'canals/tools/completion'
+require 'thor'
+
+module Canals
+  module Cli
+    class Setup < Thor
+      include Thor::Actions
+
+      desc "wizard", "Run the setup wizard"
+      def wizard
+        say "Welcome to the Canals Setup Wizard!", :green
+        setup_first_environment
+        setup_first_tunnel
+        check_install_completion
+        say "Setup complete. Thanks! :)", :green
+      end
+
+      desc "completion", "Setup bash completion"
+      def completion
+        install_completion
+      end
+
+      no_commands do
+        def setup_first_environment
+          say "We'll start by setting up your first environment", :green
+          say "An 'environment' is the server you connect your tunnels through. you can have many environments."
+          say "The first environment is the default one used for new connections (but you can always change this default in the future"
+          say ""
+          return unless yes? "Wait, should we setup your first environment?", :green
+          opts = {}
+          opts["name"]     = ask "  Name for environment:"
+          opts["hostname"] = ask "  Hostname:"
+          opts["user"]     = ask "  User:"
+          opts["pem"]      = ask "  PEM file:", :path => true
+          opts["default"]  = true
+          opts.delete_if { |key, value| value.to_s.strip.empty? }
+          if opts["name"].nil? || opts["hostname"].nil?
+            say "couldn't add first environment, use 'canal environment create ...' to add it manually.", :red
+            return
+          end
+          env = Canals::Environment.new(opts)
+          Canals.repository.add_environment(env)
+          say "Environment added. To add more environments in the future, use 'canal environment create...'", :green
+        end
+
+        def setup_first_tunnel
+          return unless yes? "Should we setup a first tunnel?", :green
+
+          opts = {}
+          shell.padding += 1
+          opts["name"]        = ask "Name for Tunnel:"
+          opts["remote_host"] = ask "Remote host:"
+          opts["remote_port"] = ask "Remote port:"
+          opts["local_port"]  = ask "Local port:", :default =>opts["remote_port"]
+          use_env             = !Canals.repository.environment.nil? && yes?("* Use stored environment?", :bold)
+          if use_env
+            opts["env"]       = ask "Environment:", :default => Canals.repository.environment.name
+          else
+            opts["hostname"] = ask "Hostname:"
+            opts["user"]     = ask "User:"
+            opts["pem"]      = ask "PEM file:", :path => true
+          end
+          opts.delete_if { |key, value| value.to_s.strip.empty? }
+          shell.padding -= 1
+          opts = Canals::CanalOptions.new(opts)
+          Canals.create_tunnel(opts)
+          say "Tunnel added. To add more tunnels in the future, use 'canal create...'", :green
+        end
+
+        def check_install_completion
+          if !check(Canals::Tools::Completion.completion_installed?, "Checking if shell completion is installed...")
+            yes?('Shell completion not installed. Would you like to install it now? ') && install_completion
+          end
+        end
+
+        def install_completion
+          Canals::Tools::Completion.install_completion
+          say "Shell completion installed.", :green
+        end
+
+        def check(check_result, message)
+          spaces = "  " * (shell.padding + 1)
+          say "#{spaces}#{message}#{spaces}#{humanize(check_result)}"
+          return check_result
+        end
+
+        def humanize(bool)
+          bool ? set_color("yes", :green) : set_color("no", :red)
+        end
+      end
+
+      default_task :wizard
+    end
+  end
+end
+
+

data/lib/canals/cli.rb

@@ -0,0 +1,90 @@
+require 'canals'
+require 'canals/options'
+require 'canals/environment'
+require 'canals/cli/environment'
+require 'canals/cli/session'
+require 'canals/cli/helpers'
+require 'canals/cli/setup'
+require 'canals/cli/list'
+require 'canals/core_ext/shell_colors'
+require 'thor'
+
+module Canals
+  module Cli
+    class Application < Thor
+      include Thor::Actions
+      include Canals::Cli::Helpers
+
+      def initialize(*args)
+        super
+        startup_checks
+      end
+
+      desc 'create NAME REMOTE_HOST REMOTE_PORT [LOCAL_PORT]', "Create a new tunnel; if LOCAL_PORT isn't supplied, REMOTE_PORT will be used as LOCAL"
+      method_option :env,      :type => :string, :desc => "The proxy environment to use"
+      method_option :hostname, :type => :string, :desc => "The proxy host we will use to connect through"
+      method_option :user,     :type => :string, :desc => "The user for the ssh proxy host"
+      def create(name, remote_host, remote_port, local_port=nil)
+        opts = {"name" => name, "remote_host" => remote_host, "remote_port" => remote_port, "local_port" => local_port}.merge(options)
+        opts = Canals::CanalOptions.new(opts)
+        Canals.create_tunnel(opts)
+        say "Tunnel #{name.inspect} created.", :green
+      end
+
+      desc 'start NAME', 'Start tunnel'
+      def start(name)
+        tstart(name)
+      end
+
+      desc 'stop NAME', 'Stop tunnel'
+      def stop(name)
+        tstop(name)
+      end
+
+      desc 'restart NAME', 'Restart tunnel'
+      def restart(name)
+        trestart(name)
+      end
+
+      desc "repo", "Show the available tunnels, for given enviroment if given"
+      method_option :full, :type => :boolean, :desc => "Show full data on repostitory"
+      method_option :env,  :type => :string , :desc => "Show data only on given environment"
+      method_option :'sort-by',  :type => :string, :desc => "Sort by this field", :default => "name"
+      def repo
+        if Canals.repository.empty?
+          say "Repository is currently empty."
+          return
+        end
+        require 'terminal-table'
+        require 'canals/core_ext/string'
+        columns = ["name", "remote_host", "remote_port", "local_port"]
+        columns_extra = ["bind_address", "env_name", "user", "hostname"]
+        if options[:full]
+          columns += columns_extra
+        end
+
+        env = options[:env]
+        sort_by = options[:'sort-by'].downcase.split.join("_").to_sym
+        rows = Canals.repository.select { |conf| env.nil? || conf.env_name == env }
+                                .sort   { |a,b| a.send(sort_by) <=> b.send(sort_by) rescue a.name <=> b.name }
+                                .map    { |conf| columns.map{ |c| conf.send c.to_sym } }
+        table = Terminal::Table.new :headings => columns.map{|c| c.sub("_"," ").titleize }, :rows => rows
+        say table
+        say "* use --full to show more data", [:white, :dim] if !options[:full]
+      end
+
+      desc "environment SUBCOMMAND", "Environment related command (use 'canal environment help' to find out more)"
+      subcommand "environment", Canals::Cli::Environment
+
+      desc "session SUBCOMMAND", "Session related commands (use 'canal session help' to find out more)"
+      subcommand "session", Canals::Cli::Session
+
+      desc "setup", "Setup related commands (use 'canal setup help' to find out more)"
+      subcommand "setup", Canals::Cli::Setup
+
+      desc "list", "hidden lists for autocompletion", :hide => true
+      subcommand "list", Canals::Cli::List
+
+    end
+  end
+end

data/lib/canals/config.rb

@@ -0,0 +1,37 @@
+require 'psych'
+require 'pathname'
+require 'forwardable'
+
+module Canals
+  class Config
+    extend Forwardable
+
+    def initialize(root = nil)
+      @root = root
+      @config = load_config(global_config_file)
+    end
+
+    def_delegators :@config, :[], :[]=
+
+    def load_config(config_file)
+      valid_file = config_file && config_file.exist? && !config_file.size.zero?
+      return {} if !valid_file
+      return Psych.load_file(config_file)
+    end
+
+    def save!
+      FileUtils.mkdir_p(global_config_file.dirname)
+      File.open(global_config_file, 'w') do |file|
+        file.write(Psych.dump(@config))
+      end
+    end
+
+    private
+
+    def global_config_file
+      file = File.join(Dir.home, '.canals/config')
+      Pathname.new(file)
+    end
+
+  end
+end