canals 0.8.0

data/lib/canals/core.rb

@@ -0,0 +1,69 @@
+require 'open3'
+
+module Canals
+  class << self
+
+    def create_tunnel(tunnel_opts)
+      Canals.repository.add tunnel_opts
+    end
+
+    def start(tunnel_opts)
+      if tunnel_opts.instance_of? String
+        tunnel_opts = Canals.repository.get(tunnel_opts)
+      end
+      tunnel_start(tunnel_opts)
+      pid = tunnel_pid(tunnel_opts)
+      Canals.session.add({name: tunnel_opts.name, pid: pid, socket: socket_file(tunnel_opts)})
+      pid.to_i
+    end
+
+    def stop(tunnel_opts)
+      if tunnel_opts.instance_of? String
+        tunnel_opts = Canals.repository.get(tunnel_opts)
+      end
+      tunnel_close(tunnel_opts)
+      Canals.session.del(tunnel_opts.name)
+    end
+
+    def restart(tunnel_opts)
+      stop(tunnel_opts)
+      start(tunnel_opts)
+    end
+
+    def isalive?(tunnel_opts)
+      if tunnel_opts.instance_of? String
+        tunnel_opts = Canals.repository.get(tunnel_opts)
+      end
+      !!tunnel_pid(tunnel_opts)
+    end
+
+    private
+
+    def socket_file(tunnel_opts)
+      "/tmp/canals/canal.#{tunnel_opts.name}.sock"
+    end
+
+    def tunnel_start(tunnel_opts)
+      FileUtils.mkdir_p("/tmp/canals")
+      cmd = "ssh -M -S #{socket_file(tunnel_opts)} -fnNT -L #{tunnel_opts.bind_address}:#{tunnel_opts.local_port}:#{tunnel_opts.remote_host}:#{tunnel_opts.remote_port} #{tunnel_opts.proxy}"
+      system(cmd)
+    end
+
+    def tunnel_check(tunnel_opts)
+      cmd = "ssh -S #{socket_file(tunnel_opts)} -O check #{tunnel_opts.proxy}"
+      Open3.capture2e(cmd)
+    end
+
+    def tunnel_close(tunnel_opts)
+      cmd = "ssh -S #{socket_file(tunnel_opts)} -O exit #{tunnel_opts.proxy}"
+      Open3.capture2e(cmd)
+    end
+
+    def tunnel_pid(tunnel_opts)
+      stdout, _ = tunnel_check(tunnel_opts)
+      m = /\(pid=(.*)\)/.match(stdout)
+      m[1].to_i if m
+    end
+
+  end
+end

data/lib/canals/core_ext/shell_colors.rb

@@ -0,0 +1,15 @@
+require 'thor'
+
+class Thor
+  module Shell
+    class Color < Basic
+      # The start of an ANSI dim sequence.
+      DIM       = "\e[2m"
+      # The start of an ANSI underline sequence.
+      UNDERLINE = "\e[4m"
+
+      # Set the terminal's foreground ANSI color to dark gray.
+      DARK_GRAY = "\e[90m"
+    end
+  end
+end

data/lib/canals/core_ext/string.rb

@@ -0,0 +1,6 @@
+
+class String
+  def titleize
+    split(/(\W)/).map(&:capitalize).join
+  end
+end

data/lib/canals/environment.rb

@@ -0,0 +1,40 @@
+require 'psych'
+
+module Canals
+  class CanalEnvironmentError < StandardError; end
+
+  class Environment
+    attr_reader :name, :user, :hostname, :pem
+    def initialize(args)
+      @args = validate?(args)
+      @name = @args["name"]
+      @user = @args["user"]
+      @hostname = @args["hostname"]
+      @pem = @args["pem"]
+    end
+
+    def validate?(args)
+      vargs = args.dup
+      raise CanalEnvironmentError.new("Missing option: \"name\" in environment creation") if args["name"].nil?
+      vargs
+    end
+
+    def default=(val)
+      @args["default"] = !!val
+    end
+
+    def is_default?
+      !!@args["default"]
+    end
+
+    def to_yaml
+      Psych.dump(@args)
+    end
+
+    def to_hash
+      @args.dup
+    end
+
+  end
+end
+

data/lib/canals/options.rb

@@ -0,0 +1,75 @@
+require 'psych'
+
+module Canals
+  class CanalOptionError < StandardError; end
+
+  class CanalOptions
+    BIND_ADDRESS = "127.0.0.1"
+    attr_reader :name, :remote_host, :remote_port, :local_port, :env_name, :env
+
+    def initialize(args)
+      @args = validate?(args)
+      @name = @args["name"]
+      @remote_host = @args["remote_host"]
+      @remote_port = @args["remote_port"]
+      @local_port = @args["local_port"]
+      @env_name = @args['env']
+      @env = Canals.repository.environment(@env_name)
+    end
+
+    def bind_address
+      return @args["bind_address"] if @args["bind_address"]
+      return BIND_ADDRESS
+    end
+
+    def hostname
+      get_env_var("hostname")
+    end
+
+    def user
+      get_env_var("user")
+    end
+
+    def pem
+      get_env_var("pem")
+    end
+
+    def proxy
+      prxy = ""
+      prxy += "-i #{pem} " if pem
+      prxy += "#{user}@#{hostname}"
+      prxy
+    end
+
+    def to_yaml
+      Psych.dump(@args)
+    end
+
+    def to_hash
+      @args.dup
+    end
+
+    private
+
+    def validate?(args)
+      vargs = args.dup
+      raise CanalOptionError.new("Missing option: \"name\" in canal creation") if args["name"].nil?
+      raise CanalOptionError.new("Missing option: \"remote_host\" in canal creation") if args["remote_host"].nil?
+      raise CanalOptionError.new("Missing option: \"remote_port\" in canal creation") if args["remote_port"].nil?
+      vargs["remote_port"] = vargs["remote_port"].to_i
+      if vargs["local_port"].nil?
+        vargs["local_port"] = vargs["remote_port"]
+      else
+        vargs["local_port"] = vargs["local_port"].to_i
+      end
+      vargs
+    end
+
+    def get_env_var(var)
+      return @args[var] if @args[var]
+      return @env.send var.to_sym if @env
+      nil
+    end
+
+  end
+end

data/lib/canals/repository.rb

@@ -0,0 +1,87 @@
+require 'psych'
+require 'pathname'
+require 'forwardable'
+require 'canals/environment'
+
+module Canals
+  class Repository
+    include Enumerable
+    extend Forwardable
+
+    ENVIRONMENTS = :environments
+    TUNNELS = :tunnels
+
+    def initialize(root = nil)
+      @root = root
+      @repo = load_repository(repo_file)
+    end
+
+    def_delegator :@repo, :[]
+
+    def each(&block)
+      @repo[TUNNELS].map{ |n, r| Canals::CanalOptions.new(r) }.each(&block)
+    end
+
+    def empty?
+      @repo[TUNNELS].empty?
+    end
+
+    def add(options, save=true)
+      @repo[TUNNELS][options.name] = options.to_hash
+      if options.env_name.nil? && !options.env.nil? && options.env.is_default?
+        @repo[TUNNELS][options.name]["env"] = options.env.name
+      end
+      save! if save
+    end
+
+    def get(name)
+      CanalOptions.new(@repo[:tunnels][name])
+    end
+
+    def add_environment(environment, save=true)
+      if environment.is_default?
+        @repo[ENVIRONMENTS].each { |name, env| env.delete("default") }
+      end
+      if @repo[ENVIRONMENTS].empty?
+        environment.default = true
+      end
+      @repo[ENVIRONMENTS][environment.name] = environment.to_hash
+      save! if save
+    end
+
+    def save!
+      FileUtils.mkdir_p(repo_file.dirname)
+      File.open(repo_file, 'w') do |file|
+        file.write(Psych.dump(@repo))
+      end
+    end
+
+    def environment(name=nil)
+      if name.nil?
+        args = @repo[ENVIRONMENTS].select{ |n,e| e["default"] }.values[0]
+      else
+        args = @repo[ENVIRONMENTS][name]
+      end
+      Canals::Environment.new(args) if !args.nil?
+    end
+
+    def environments
+      @repo[ENVIRONMENTS].map { |n, e| Canals::Environment.new(e) }
+    end
+
+    private
+
+    def repo_file
+      file = File.join(Dir.home, '.canals/repository')
+      Pathname.new(file)
+    end
+
+    def load_repository(repository_file)
+      valid_file = repository_file && repository_file.exist? && !repository_file.size.zero?
+      return { ENVIRONMENTS => {}, TUNNELS => {} } if !valid_file
+      return Psych.load_file(repository_file)
+    end
+
+  end
+end
+

data/lib/canals/session.rb

@@ -0,0 +1,64 @@
+require 'psych'
+require 'pathname'
+require 'forwardable'
+
+module Canals
+  class Session
+    include Enumerable
+    extend Forwardable
+
+    def initialize
+      @session = load_session(session_file)
+    end
+
+    def_delegator :@session, :[]
+
+    def each(&block)
+      @session.each(&block)
+    end
+
+    def empty?
+      @session.empty?
+    end
+
+    def add(session, save=true)
+      @session.push(session)
+      save! if save
+    end
+
+    def del(name, save=true)
+      @session.delete_if{ |s| s[:name] == name }
+      save! if save
+    end
+
+    def get(session_id)
+      case session_id
+      when Numeric
+        @session.find{ |s| s[:pid] == session_id }
+      when String
+        @session.find{ |s| s[:name] == session_id }
+      end
+    end
+
+    def save!
+      FileUtils.mkdir_p(session_file.dirname)
+      File.open(session_file, 'w') do |file|
+        file.write(Psych.dump(@session))
+      end
+    end
+
+    private
+
+    def session_file
+      file = File.join(Dir.home, '.canals/session')
+      Pathname.new(file)
+    end
+
+    def load_session(_session_file)
+      valid_file = _session_file && _session_file.exist? && !_session_file.size.zero?
+      return [] if !valid_file
+      return Psych.load_file(_session_file)
+    end
+
+  end
+end

data/lib/canals/tools/assets.rb

@@ -0,0 +1,21 @@
+module Canals
+  module Tools
+    module Assets
+      BASE = File.expand_path('../../../../assets', __FILE__)
+      extend self
+
+      def asset_path(file)
+        File.expand_path(file, BASE)
+      end
+
+      def asset(file)
+        File.read(asset_path(file))
+      end
+
+      class << self
+        alias [] asset_path
+        alias read asset
+      end
+    end
+  end
+end

data/lib/canals/tools/completion.rb

@@ -0,0 +1,47 @@
+require 'canals'
+require 'canals/tools/assets'
+
+module Canals
+  module Tools
+    module Completion
+      include FileUtils
+      extend self
+
+      def config_path
+        File.expand_path(".canals", ENV['HOME'])
+      end
+
+      def cmp_file
+        File.expand_path('canals.sh', config_path)
+      end
+
+      def install_completion
+        update_completion
+        source = "source " << cmp_file
+
+        rcfile = File.expand_path('.bashrc', ENV['HOME'])
+        return if File.read(rcfile).include? source
+        File.open(rcfile, 'a') { |f| f.puts("", "# added by canals gem", "[ -f #{cmp_file} ] && #{source}") }
+      end
+
+      def update_completion
+        mkdir_p(config_path)
+        cp(Assets['canals.sh'], cmp_file)
+        update_config
+      end
+
+      def update_config
+        Canals.config[:completion_version] = Canals::VERSION
+        Canals.config.save!
+      end
+
+      def completion_installed?
+        source = "source " << cmp_file
+        rcfile = File.expand_path('.bashrc', ENV['HOME'])
+        return false unless File.read(rcfile).include? source
+        true
+      end
+    end
+  end
+end
+

data/lib/canals/version.rb

@@ -0,0 +1,6 @@
+module Canals
+
+  # Canals gem current version
+  VERSION = "0.8.0"
+
+end

data/lib/canals.rb

@@ -0,0 +1,39 @@
+require 'logger'
+require 'canals/core'
+
+# a gem for managing ssh tunnel connections
+module Canals
+  extend self
+
+  autoload :Repository, "canals/repository"
+  autoload :Session, "canals/session"
+  autoload :Config, 'canals/config'
+  autoload :Version, 'canals/version'
+
+
+  attr_accessor :logger
+
+  def config
+    return @config if defined?(@config)
+    @config = Config.new(File.join(Dir.home, '.canals'))
+  end
+
+  def repository
+    return @repository if defined?(@repository)
+    @repository = Repository.new
+  end
+
+  def environments
+    return @repository.environments if defined?(@repository)
+    @repository = Repository.new
+    @repository.environments
+  end
+
+  def session
+    return @session if defined?(@session)
+    @session = Session.new
+  end
+end
+
+# default logger
+Canals.logger = Logger.new(STDERR)

data/spec/canals/environment_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+require 'canals/environment'
+require 'psych'
+
+describe Canals::Environment do
+  let(:name)  { "blah" }
+  let(:hostname)  { "nat.example.com" }
+  let(:user)  { "user" }
+  let(:pem)  { "/tmp/file.pem" }
+
+  describe "name" do
+    it "contains 'name'" do
+      args = {"name" => name}
+      env = Canals::Environment.new(args)
+      expect(env.name).to eq name
+    end
+
+    it "raises error when 'name' is not availble" do
+      args = {"hostname" => hostname}
+      expect{Canals::Environment.new(args)}.to raise_error(Canals::CanalEnvironmentError)
+    end
+  end
+
+  describe "hostname" do
+    it "contains 'hostname'" do
+      args = {"name" => name, "hostname" => hostname}
+      env = Canals::Environment.new(args)
+      expect(env.hostname).to eq hostname
+    end
+  end
+
+  describe "user" do
+    it "contains 'user'" do
+      args = {"name" => name, "user" => user}
+      env = Canals::Environment.new(args)
+      expect(env.user).to eq user
+    end
+  end
+
+  describe "pem" do
+    it "contains 'pem'" do
+      args = {"name" => name, "pem" => pem}
+      env = Canals::Environment.new(args)
+      expect(env.pem).to eq pem
+    end
+  end
+
+  describe "default" do
+    it "returns 'defualt' true if default" do
+      args = {"name" => name, "default" => true}
+      env = Canals::Environment.new(args)
+      expect(env.is_default?).to eq true
+    end
+
+    it "returns 'defualt' false if default" do
+      args = {"name" => name, "default" => false}
+      env = Canals::Environment.new(args)
+      expect(env.is_default?).to eq false
+    end
+
+    it "returns 'defualt' false if default not availble" do
+      args = {"name" => name}
+      env = Canals::Environment.new(args)
+      expect(env.is_default?).to eq false
+    end
+
+    it "default can be changed" do
+      args = {"name" => name, "default" => true}
+      env = Canals::Environment.new(args)
+      expect(env.is_default?).to eq true
+      expect(env.to_hash["default"]).to eq true
+      env.default = false
+      expect(env.is_default?).to eq false
+      expect(env.to_hash["default"]).to eq false
+    end
+  end
+end