ssh-hull 1.0.0

data/exe/ssh-hull

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/ssh-hull'
+
+# Parse options
+cli = SSHTunnel::CLI.instance
+cli.parse
+
+# Start application
+status = cli.run
+exit status

data/exe/ssh-tunnel

@@ -0,0 +1 @@
+ssh-hull

data/lib/ssh-hull/cli.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module SSHTunnel
+  class CLI
+    include Singleton
+
+    def parse(args = ARGV)
+      setup_options(args)
+      validate!
+      load_config!
+    end
+
+
+    def run
+      compile_resources!
+      load_resources!
+      set_locales!
+      boot_application!
+    end
+
+
+    private
+
+
+      def setup_options(args)
+        @opts = parse_options(args)
+      end
+
+
+      def parse_options(argv)
+        opts = {}
+        @parser = option_parser(opts)
+        @parser.parse!(argv)
+        opts
+      end
+
+
+      def option_parser(opts)
+        parser = OptionParser.new do |o|
+          o.on '-C', '--config PATH', 'path to YAML config file' do |arg|
+            opts[:config_file] = arg
+          end
+        end
+
+        parser.banner = 'ssh-hull [options]'
+        parser.on_tail '-h', '--help', 'Show help' do
+          puts parser
+          exit 1
+        end
+
+        parser
+      end
+
+
+      def validate!
+        if @opts[:config_file]
+          raise ArgumentError, "No such file #{@opts[:config_file]}" unless File.exist?(@opts[:config_file])
+        else
+          @opts[:config_file] = Pathname.new(File.expand_path('~/.config/ssh-hull/config.json'))
+        end
+      end
+
+
+      def load_config!
+        SSHTunnel.load_config(@opts[:config_file])
+      end
+
+
+      def compile_resources!
+        cmd = [
+          'glib-compile-resources',
+          '--target',    SSHTunnel.resources_bin.to_s,
+          '--sourcedir', SSHTunnel.resources_path.to_s,
+          SSHTunnel.resources_xml.to_s
+        ]
+        system(*cmd)
+      end
+
+
+      def load_resources!
+        resources = Gio::Resource.load(SSHTunnel.resources_bin.to_s)
+        Gio::Resources.register(resources)
+      end
+
+
+      def set_locales!
+        I18n::Backend::Simple.include(I18n::Backend::Fallbacks)
+        I18n.load_path << Dir[SSHTunnel.locales_path]
+
+        I18n.enforce_available_locales = false
+        I18n.available_locales         = %i[en fr]
+        I18n.default_locale            = SSHTunnel.current_locale
+        I18n.fallbacks                 = [:en]
+      end
+
+
+      def boot_application!
+        SSHTunnel.config.hosts.each(&:auto_start!)
+        app = SSHTunnel::UI::Application.new
+
+        begin
+          status = app.run
+        rescue Interrupt => e
+          status = 0
+        ensure
+          SSHTunnel.config.hosts.each(&:stop_tunnels!)
+        end
+
+        status
+      end
+
+  end
+end

data/lib/ssh-hull/logger.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module SSHTunnel
+  class Logger < ::Logger
+  end
+end

data/lib/ssh-hull/ui/application.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module SSHTunnel
+  module UI
+    class Application < Gtk::Application
+
+      attr_reader :config
+
+
+      # rubocop:disable Metrics/MethodLength
+      def initialize
+        super 'com.ungtb10d.ssh-hull', Gio::ApplicationFlags::FLAGS_NONE
+
+        @config = SSHTunnel.config
+
+        signal_connect :startup do |application|
+          quit_accels = ['<Ctrl>Q']
+
+          action = Gio::SimpleAction.new('quit')
+          action.signal_connect :activate do |_action, _parameter|
+            application.quit
+          end
+
+          application.add_action(action)
+          application.set_accels_for_action('app.quit', quit_accels)
+        end
+
+        signal_connect :activate do |application|
+          window = SSHTunnel::UI::Windows::ApplicationWindow.new(application)
+          window.present
+
+          # Gtk::StatusIcon is deprecated
+          # See: https://developer.gnome.org/gtk3/stable/GtkStatusIcon.html#gtk-status-icon-new
+          # SSHTunnel::UI::StatusIcon.new(application, window)
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+
+      def quit
+        @config.hosts.map(&:stop_tunnels!)
+        super
+      end
+
+    end
+  end
+end

data/lib/ssh-hull/ui/forms/application_form.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module SSHTunnel
+  module UI
+    module Forms
+      class ApplicationForm
+
+        include ActiveModel::Model
+        include ActiveModel::Validations::Callbacks
+
+        class_attribute :attributes
+
+        attr_reader :model
+
+        class << self
+
+          def attribute(name, opts = {})
+            self.attributes ||= []
+            create_attribute(name, opts)
+            self.attributes += [name]
+          end
+
+          # rubocop:disable Layout/EmptyLinesAroundAttributeAccessor
+          private def create_attribute(name, opts = {})
+            required = opts.fetch(:required, false)
+            attr_accessor name
+            validates_presence_of(name) if required
+          end
+          # rubocop:enable Layout/EmptyLinesAroundAttributeAccessor
+
+        end
+
+
+        def initialize(model)
+          @model = model
+        end
+
+
+        def submit(params)
+          self.class.attributes.each do |attr|
+            if params[attr]
+              method = "#{attr}="
+              __send__(method, params[attr])
+            end
+          end
+        end
+
+
+        def save
+          self.class.attributes.each do |attr|
+            value  = __send__(attr)
+            method = "#{attr}="
+            model.__send__(method, value)
+          end
+          model
+        end
+
+
+        private
+
+
+          def cast_to_int(value)
+            Integer(value) rescue value
+          end
+
+      end
+    end
+  end
+end

data/lib/ssh-hull/ui/forms/host_form.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module SSHTunnel
+  module UI
+    module Forms
+      class HostForm < ApplicationForm
+
+        attribute :name, required: true
+        attribute :user, required: true
+        attribute :host, required: true
+        attribute :port, required: true
+        attribute :identity_file
+
+        validates_inclusion_of :port, in: 0..65_535
+
+        # Callbacks
+        before_validation :cast_port_to_int
+
+
+        def cast_port_to_int
+          self.port = cast_to_int(port)
+        end
+
+      end
+    end
+  end
+end

data/lib/ssh-hull/ui/forms/tunnel_form.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module SSHTunnel
+  module UI
+    module Forms
+      class TunnelForm < ApplicationForm
+
+        attribute :name,        required: true
+        attribute :type,        required: true
+        attribute :local_host,  required: true
+        attribute :local_port,  required: true
+        attribute :remote_host, required: true
+        attribute :remote_port, required: true
+        attribute :auto_start
+
+        validates_inclusion_of :local_port,  in: 0..65_535
+        validates_inclusion_of :remote_port, in: 0..65_535
+
+        # Callbacks
+        before_validation :cast_port_to_int
+
+
+        def cast_port_to_int
+          self.local_port  = cast_to_int(local_port)
+          self.remote_port = cast_to_int(remote_port)
+        end
+
+      end
+    end
+  end
+end

data/lib/ssh-hull/ui/helpers/application_window_helper.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+module SSHTunnel
+  module UI
+    module Helpers
+      module ApplicationWindowHelper
+
+        include SSHTunnel::UI::Helpers::Common::MinimizeHelper
+        include SSHTunnel::UI::Helpers::Common::ToolbarHelper
+        include SSHTunnel::UI::Helpers::Common::TranslationHelper
+        include SSHTunnel::UI::Helpers::Common::TreeViewHelper
+
+
+        def self.included(base)
+          base.extend(ClassMethods)
+          base.extend(SSHTunnel::UI::Helpers::Common::FormHelper::ClassMethods)
+        end
+
+
+        module ClassMethods
+
+          MENU_ITEMS      = %w[quit about].freeze
+          TOOLBAR_BUTTONS = %w[add edit remove start stop].freeze
+
+          def init
+            bind_menu_entries(MENU_ITEMS)
+            bind_buttons(TOOLBAR_BUTTONS)
+          end
+
+        end
+
+
+        def load_hosts_treeview
+          # create treeview
+          treeview_model  = create_hosts_treeview_model(all_hosts)
+          @hosts_treeview = create_hosts_treeview(treeview_model)
+
+          # Render treeview
+          hosts_scrolled_window.shadow_type = :etched_in
+          hosts_scrolled_window.set_policy(:automatic, :automatic)
+          hosts_scrolled_window.add(@hosts_treeview)
+          @hosts_treeview.show
+        end
+
+
+        def reload_hosts_treeview
+          @hosts_treeview.destroy
+          load_hosts_treeview
+        end
+
+
+        private
+
+
+          HOST_STATE_COLUMN         = 0
+          HOST_UUID_COLUMN          = 1
+          HOST_NAME_COLUMN          = 2
+          HOST_HOST_COLUMN          = 3
+          HOST_USER_COLUMN          = 4
+          HOST_PORT_COLUMN          = 5
+          TUNNEL_NAME_COLUMN        = 6
+          TUNNEL_TYPE_COLUMN        = 7
+          TUNNEL_LOCAL_HOST_COLUMN  = 8
+          TUNNEL_LOCAL_PORT_COLUMN  = 9
+          TUNNEL_REMOTE_HOST_COLUMN = 10
+          TUNNEL_REMOTE_PORT_COLUMN = 11
+          TUNNEL_AUTO_START_COLUMN  = 12
+
+
+          # rubocop:disable Metrics/MethodLength
+          def create_hosts_treeview_model(hosts)
+            model = Gtk::TreeStore.new(String, String, String, String, String, String, String, String, String, String, String, String, String)
+
+            hosts.each do |host|
+              iter = model.append(nil)
+
+              iter[HOST_STATE_COLUMN]         = host.started? ? 'gtk-yes' : 'gtk-no'
+              iter[HOST_UUID_COLUMN]          = host.uuid
+              iter[HOST_NAME_COLUMN]          = host.name
+              iter[HOST_USER_COLUMN]          = host.user
+              iter[HOST_HOST_COLUMN]          = host.host
+              iter[HOST_PORT_COLUMN]          = host.port
+              iter[TUNNEL_NAME_COLUMN]        = ''
+              iter[TUNNEL_TYPE_COLUMN]        = ''
+              iter[TUNNEL_LOCAL_HOST_COLUMN]  = ''
+              iter[TUNNEL_LOCAL_PORT_COLUMN]  = ''
+              iter[TUNNEL_REMOTE_HOST_COLUMN] = ''
+              iter[TUNNEL_REMOTE_PORT_COLUMN] = ''
+              iter[TUNNEL_AUTO_START_COLUMN]  = ''
+
+              tunnels = host.tunnels
+
+              # add children
+              tunnels.each do |tunnel|
+                child_iter = model.append(iter)
+
+                child_iter[TUNNEL_NAME_COLUMN]        = tunnel.name
+                child_iter[TUNNEL_TYPE_COLUMN]        = tunnel.type
+                child_iter[TUNNEL_LOCAL_HOST_COLUMN]  = tunnel.local_host
+                child_iter[TUNNEL_LOCAL_PORT_COLUMN]  = tunnel.local_port
+                child_iter[TUNNEL_REMOTE_HOST_COLUMN] = tunnel.remote_host
+                child_iter[TUNNEL_REMOTE_PORT_COLUMN] = tunnel.remote_port
+                child_iter[TUNNEL_AUTO_START_COLUMN]  = tunnel.auto_start?.to_s
+              end
+            end
+
+            model
+          end
+          # rubocop:enable Metrics/MethodLength
+
+
+          def create_hosts_treeview(model)
+            treeview = Gtk::TreeView.new(model)
+
+            # configure treeview selection
+            # sub-rows are not clickable
+            treeview.selection.mode = :single
+            treeview.selection.set_select_function do |_selection, _model, path, _path_currentry_selected|
+              path.to_s.include?(':') ? false : true
+            end
+
+            # Disable buttons if tunnels are running
+            hosts_treeview_bind_single_click(treeview)
+
+            # Start host tunnels on double-click
+            hosts_treeview_bind_double_click(treeview)
+
+            # Popup the menu on right click
+            hosts_treeview_bind_right_click(treeview)
+
+            # add columns to the tree view
+            hosts_treeview_add_columns(treeview)
+
+            treeview
+          end
+
+
+          def hosts_treeview_bind_single_click(treeview)
+            treeview.selection.signal_connect :changed do
+              with_host_model do |object|
+                disable_buttons_if_tunnels_running(object)
+              end
+            end
+          end
+
+
+          def hosts_treeview_bind_double_click(treeview)
+            treeview.signal_connect :row_activated do |_widget, path|
+              if path.to_s.include?(':')
+                false
+              else
+                with_host_model do |object|
+                  object.toggle_tunnels!
+                  reload_hosts_treeview
+                end
+              end
+            end
+          end
+
+
+          # rubocop:disable Style/SoleNestedConditional
+          def hosts_treeview_bind_right_click(treeview)
+            treeview.signal_connect :button_press_event do |widget, event|
+              if event.is_a?(Gdk::EventButton) && event.button == 3
+                if widget.selection.selected && !widget.selection.selected.path.to_s.include?(':')
+                  # TODO: finish implementation of right click
+                  puts 'RIGHT CLICK'
+                end
+              end
+            end
+          end
+          # rubocop:enable Style/SoleNestedConditional
+
+
+          def hosts_treeview_add_columns(treeview)
+            add_image_column treeview,  t('view.host.state'),         'icon-name': HOST_STATE_COLUMN
+            add_text_column  treeview,  t('view.host.uuid'),          text: HOST_UUID_COLUMN, visible: false
+            add_text_column  treeview,  t('view.host.name'),          text: HOST_NAME_COLUMN
+            add_text_column  treeview,  t('view.host.user'),          text: HOST_USER_COLUMN
+            add_text_column  treeview,  t('view.host.host'),          text: HOST_HOST_COLUMN
+            add_text_column  treeview,  t('view.host.port'),          text: HOST_PORT_COLUMN
+            add_text_column  treeview,  t('view.tunnel.name'),        text: TUNNEL_NAME_COLUMN
+            add_text_column  treeview,  t('view.tunnel.type'),        text: TUNNEL_TYPE_COLUMN
+            add_text_column  treeview,  t('view.tunnel.local_host'),  text: TUNNEL_LOCAL_HOST_COLUMN
+            add_text_column  treeview,  t('view.tunnel.local_port'),  text: TUNNEL_LOCAL_PORT_COLUMN
+            add_text_column  treeview,  t('view.tunnel.remote_host'), text: TUNNEL_REMOTE_HOST_COLUMN
+            add_text_column  treeview,  t('view.tunnel.remote_port'), text: TUNNEL_REMOTE_PORT_COLUMN
+            add_text_column  treeview,  t('view.tunnel.auto_start'),  text: TUNNEL_AUTO_START_COLUMN
+          end
+
+
+          def all_hosts
+            @application.config.hosts
+          end
+
+
+          def find_host_model
+            return nil if @hosts_treeview.selection.selected.blank?
+
+            uuid = @hosts_treeview.selection.selected.get_value(HOST_UUID_COLUMN)
+            all_hosts.find { |h| h.uuid == uuid }
+          end
+
+
+          def with_host_model
+            object = find_host_model
+            yield object if object
+          end
+
+
+          def with_new_host_model
+            yield SSHTunnel::UI::Models::Host.new
+          end
+
+
+          def disable_buttons_if_tunnels_running(host)
+            if host.started?
+              button_edit.sensitive   = false
+              button_remove.sensitive = false
+              button_start.sensitive  = false
+              button_stop.sensitive   = true
+            else
+              button_edit.sensitive   = true
+              button_remove.sensitive = true
+              button_start.sensitive  = true
+              button_stop.sensitive   = false
+            end
+          end
+
+      end
+    end
+  end
+end