cloud-sh 1.0.0

data/lib/cloud/sh/commands/refresh.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "cloud/sh/commands/base"
+
+module Cloud
+  module Sh
+    module Commands
+      class Refresh < Base
+        attr_reader :aliases
+
+        def execute
+          Cloud::Sh::Providers::DigitalOcean.refresh_k8s_configs
+          build_aliases
+          save_aliases
+        end
+
+        def build_aliases
+          @aliases = {}
+          config.accounts.each do |account|
+            puts "Refreshing account #{account.name}"
+            build_ssh_aliases(account)
+            build_db_aliases(account)
+            build_k8s_aliases(account)
+          end
+        end
+
+        def save_aliases
+          print "Saving aliases ... "
+          aliases_text = aliases.map do |alias_name, cmd|
+            "alias #{alias_name}=\"#{cmd}\""
+          end.join("\n")
+          File.write(config.aliases_file, aliases_text)
+          puts "DONE"
+        end
+
+        def build_ssh_aliases(account)
+          print " Refreshing SSH aliases ... "
+          provider = cloud_provider(account)
+          provider.servers do |server|
+            add_alias(:do, account, :ssh, server.name, "ssh #{server.ip}")
+          end
+          puts "DONE"
+        end
+
+        def build_db_aliases(account)
+          print " Refreshing DB aliases ... "
+          provider = cloud_provider(account)
+          provider.databases do |database|
+            next if database.cluster.ignore
+            if database.cluster.engine == "pg"
+              add_alias(:do, account, :psql, database.cluster, database.name, "psql \\\"#{database.uri}\\\"")
+              add_alias(:do, account, :pgdump, database.cluster, database.name, pgdump_command(database))
+              add_alias(:do, account, :pgcli, database.cluster, database.name, "pgcli \\\"#{database.uri}\\\"")
+            elsif database.cluster.engine == "mysql"
+              add_alias(:do, account, :mysql, database.cluster, database.name, mysql_command(database))
+              add_alias(:do, account, :mysqldump, database.cluster, database.name, mysqldump_command(database))
+              add_alias(:do, account, :mycli, database.cluster, database.name, "pgcli \\\"#{database.uri}\\\"")
+            elsif database.cluster.engine == "redis"
+              add_alias(:do, account, :redis, database.cluster, database.name, "redli -u \\\"#{database.uri}\\\"")
+            else
+              puts "Don't know how to handle database engine #{database.cluster.engine}"
+            end
+          end
+          puts "DONE"
+        end
+
+        def build_k8s_aliases(account)
+          print " Refreshing K8S aliases ... "
+          add_alias(:k8s, account, :ctl, kubectl)
+          provider = cloud_provider(account)
+          provider.clusters do |cluster|
+            add_alias(:k8s, account, :switch, :to, cluster, kubectl("config use-context", cluster.context))
+            add_alias(:k8s, account, :ctl, cluster, kubectl("--context #{cluster.context}"))
+            cluster.pods.each do |namespace, pods|
+              add_alias(:k8s, account, :tail, namespace, :all, "cloud-sh k8s tail --context #{cluster.context} --namespace #{namespace}")
+              pods.each do |pod|
+                add_alias(:k8s, account, :tail, namespace, pod.name, "cloud-sh k8s tail --context #{cluster.context} --namespace #{namespace} --pod #{pod.name}") unless pod.name == "console"
+                add_alias(:k8s, account, :exec, namespace, pod.name, "cloud-sh k8s exec  --context #{cluster.context} --namespace #{namespace} --pod #{pod.name}")
+                add_alias(:k8s, account, namespace, :rails, :console, "cloud-sh k8s exec --context #{cluster.context} --namespace #{namespace} --pod #{pod.name} --cmd 'bundle exec rails console'") if pod.name == "console"
+              end
+            end
+          end
+          puts "DONE"
+        end
+
+        def kubectl(*parts)
+          [
+            "kubectl",
+            "--kubeconfig=#{Cloud::Sh::Providers::DigitalOcean.kube_config}",
+            parts
+          ].flatten.join(" ")
+        end
+
+        def mysql_command(database)
+          uri = URI.parse(database.uri)
+          [ :mysql, mysql_connection_params(uri), uri.path.delete("/")].join(" ")
+        end
+
+        def mysqldump_command(database)
+          uri = URI.parse(database.uri)
+          dump_name = "#{database.db}-`date +%s`.sql"
+          [ :mysqldump, mysql_connection_params(uri), uri.path.delete("/"), "> #{dump_name}"].join(" ")
+        end
+
+        def mysql_connection_params(uri)
+          [
+            "--host=#{uri.host}",
+            "--user=#{uri.user}",
+            "--password=#{uri.password}",
+            "--port=#{uri.port}",
+            "--ssl-mode=REQUIRED"
+          ].join(" ")
+        end
+
+        def pgdump_command(database)
+          dump_name = "#{database.db}-`date +%s`.sql"
+          "pg_dump \\\"#{database.uri}\\\" -f #{dump_name}"
+        end
+
+        def add_alias(*parts, cmd)
+          alias_name = parts.map { |part| normalize_alias_part(part) }.compact.join("-")
+          aliases[alias_name] = cmd
+        end
+
+        def normalize_alias_part(part)
+          return nil if part.respond_to?(:default) && part.default
+          if part.respond_to?(:alias)
+            part = part.alias
+          elsif part.respond_to?(:name)
+            part = part.name
+          elsif part.respond_to?(:to_s)
+            part = part.to_s
+          end
+          part.tr("._", "-")
+        end
+
+        def cloud_provider(account)
+          @cloud_providers ||= {}
+          @cloud_providers[account] ||= Cloud::Sh::Providers.build(account)
+        end
+      end
+    end
+  end
+end

data/lib/cloud/sh/config.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Cloud
+  module Sh
+    class Config
+      attr_reader :accounts
+
+      def initialize
+        @accounts = []
+        read_config
+      end
+
+      def read_config
+        return unless File.exist?(config_file)
+        config = YAML.safe_load(File.read(config_file))
+        config.each do |account_config|
+          accounts << Account.new(account_config)
+        end
+      end
+
+      def config_file
+        File.expand_path(".config/cloud-sh.yml", "~")
+      end
+
+      def aliases_file
+        File.expand_path(".cloud_sh_aliases", "~/")
+      end
+    end
+
+    class Account
+      attr_reader :name, :kind, :context, :default, :clusters, :databases
+
+      def initialize(config)
+        @name = config["name"]
+        @kind = config["kind"]
+        @context = config["context"]
+        @default = config.key?("default") && !!config["default"]
+        @clusters = []
+        @databases = []
+        load_clusters(config)
+        load_databases(config)
+      end
+
+      def load_clusters(config)
+        return unless config.key?("clusters")
+        config["clusters"].each do |cluster_config|
+          clusters << Cluster.new(cluster_config)
+        end
+      end
+
+      def load_databases(config)
+        return unless config.key?("databases")
+        config["databases"].each do |database_config|
+          databases << Database.new(database_config)
+        end
+      end
+
+      def find_cluster(name)
+        clusters.find { |cluster| cluster.name == name }
+      end
+
+      def find_database(name)
+        databases.find { |database| database.name == name }
+      end
+
+      def ignore_database?(name)
+        databases.any? do |database|
+          database.name == name && database.ignore
+        end
+      end
+    end
+    class Cluster
+      attr_reader :name, :alias, :default, :ignore
+
+      def initialize(config)
+        @name = config["name"]
+        @alias = config["alias"] || @name
+        @default = config.key?("default") && !!config["default"]
+        @ignore = config.key?("ignore") && !!config["ignore"]
+      end
+
+      def enrich(object)
+        object.alias = @alias
+        object.default = default
+        object.ignore = ignore
+      end
+    end
+
+    class Database
+      attr_reader :name, :alias, :default, :ignore
+
+      def initialize(config)
+        @name = config["name"]
+        @alias = config["alias"] || @name
+        @default = config.key?("default") && !!config["default"]
+        @ignore = config.key?("ignore") && !!config["ignore"]
+      end
+
+      def enrich(object)
+        object.alias = @alias
+        object.default = default
+        object.ignore = ignore
+      end
+    end
+  end
+end

data/lib/cloud/sh/helpers/commands.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Cloud
+  module Sh
+    module Helpers
+      module Commands
+
+        def command_chain(base)
+          CmdChain.new(base)
+        end
+
+        class CmdChain
+          def initialize(base)
+            @cmd = [base]
+          end
+
+          def with(val)
+            @cmd << val
+            self
+          end
+
+          def method_missing(name, *args)
+            if args.empty?
+              @cmd << name.to_s.tr("_", "-")
+            elsif args.first.is_a?(TrueClass)
+              @cmd << "--#{name.to_s.tr("_", "-")}"
+            else
+              @cmd << "--#{name.to_s.tr("_", "-")}=#{args.first}"
+            end
+            self
+          end
+
+          def map(*fields)
+            execute.lines.map do |line|
+              values = line.split.first(fields.size)
+              OpenStruct.new(fields.zip(values).to_h)
+            end
+          end
+
+          def replace_current_process
+            exec(@cmd.join(" "))
+          end
+
+          def execute
+            cloud_sh_exec(@cmd)
+          end
+
+          def to_s
+            @cmd.join(" ")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cloud/sh/providers/base.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Cloud
+  module Sh
+    module Providers
+      def self.providers
+        @providers ||= {}
+      end
+
+      def self.add_provider(name, klass)
+        providers[name] = klass
+      end
+
+      def self.build(account)
+        return providers[account.kind].new(account) if providers.key?(account.kind)
+        raise ArgumentError, "Don't know account kind #{account.kind} for account #{account.inspect}"
+      end
+
+      class Base
+        include Cloud::Sh::Helpers::Commands
+
+        attr_reader :account
+
+        def initialize(account)
+          @account = account
+        end
+
+        def servers
+          raise NotImplementedError
+        end
+
+        def databases
+          raise NotImplementedError
+        end
+
+        def clusters
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/cloud/sh/providers/digital_ocean.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "cloud/sh/providers/base"
+require "open3"
+
+module Cloud
+  module Sh
+    module Providers
+      class DigitalOcean < Base
+        def self.refresh_k8s_configs
+          return if File.exist?(kube_config) && (Time.now.to_i - File.mtime(kube_config).to_i) < 3600
+          configs = Cloud::Sh.config.accounts.map { |account| new(account).k8s_configs }.flatten.compact
+          config = configs.shift
+          configs.each do |cfg|
+            config["clusters"] += cfg["clusters"]
+            config["contexts"] += cfg["contexts"]
+            config["users"] += cfg["users"]
+          end
+          config["current-context"] = config["contexts"].first["name"]
+          File.write(kube_config, YAML.dump(config))
+        end
+
+        def self.kube_config
+          File.expand_path(".kube/cloud_sh_config", "~/")
+        end
+
+        def servers
+          doctl.compute.droplet.list.format("Name,PublicIPv4").no_header(true).map(:name, :ip).each do |server|
+            yield server if block_given?
+          end
+        end
+
+        def databases
+          list = []
+          doctl.db.list.no_header(true).map(:id, :name, :engine).each do |cluster|
+            account.find_database(cluster.name)&.enrich(cluster)
+            defaultdb_uri = doctl.db.conn.with(cluster.id).format("URI").no_header(true).map(:uri).first.uri
+            dbs = [OpenStruct.new(name: "")] if cluster.engine == "redis"
+            dbs ||= doctl.db.db.list.with(cluster.id).no_header(true).map(:name)
+            dbs.each do |db|
+              uri = URI.parse(defaultdb_uri).tap { |uri| uri.path = "/#{db.name}" }.to_s
+              database = OpenStruct.new(cluster: cluster, name: db.name, uri: uri)
+              yield database if block_given?
+              list << database
+            end
+          end
+          list
+        end
+
+        def clusters
+          doctl.k8s.cluster.list.no_header(true).map(:id, :name).map do |cluster|
+            account.find_cluster(cluster.name)&.enrich(cluster)
+            next if cluster.ignore
+            cluster.context = k8s_context(account, cluster)
+            cluster.pods = kubectl.context(cluster.context).get.pod.all_namespaces(true).no_headers(true).map(:namespace, :name).map do |pod|
+              pod.name = k8s_pod_name(pod.name)
+              pod
+            end.group_by(&:itself).keys.group_by(&:namespace)
+            yield cluster if block_given?
+          end.compact
+        end
+
+        def k8s_configs
+          doctl.k8s.cluster.list.no_header(true).map(:id, :name).map do |cluster|
+            account.find_cluster(cluster.name)&.enrich(cluster)
+            next if cluster.ignore
+            cluster_config = YAML.load(doctl.k8s.cluster.config.show.with(cluster.id).execute)
+            cluster_config["contexts"].first["name"] = k8s_context(account, cluster)
+            cluster_config
+          end
+        end
+
+        def k8s_context(account, cluster)
+          [
+            account.name,
+            (cluster.alias unless cluster.default)
+          ].compact.join("-").tr("._", "-")
+        end
+
+        def k8s_pod_name(name)
+          parts = name.split("-")
+          parts.pop if parts.last =~ /^[a-z0-9]{5}$/
+          parts.pop if parts.last =~ /^[a-f0-9]{8,10}$/
+          parts.pop if parts.last =~ /^[a-f0-9]{8,10}$/
+          parts.join("-")
+        end
+
+        def doctl
+          command_chain("doctl").context(account.context)
+        end
+
+        def kubectl
+          command_chain("kubectl").kubeconfig(Cloud::Sh::Providers::DigitalOcean.kube_config)
+        end
+      end
+
+      add_provider("do", DigitalOcean)
+    end
+  end
+end

data/lib/cloud/sh/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Cloud
+  module Sh
+    VERSION = "1.0.0"
+  end
+end

data/lib/cloud/sh.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "cloud/sh/version"
+require "gli"
+
+require "cloud/sh/config"
+
+require "cloud/sh/helpers/commands"
+
+require "cloud/sh/commands/refresh"
+require "cloud/sh/commands/k8s_tail"
+require "cloud/sh/commands/k8s_exec"
+
+require "cloud/sh/providers/digital_ocean"
+
+module Cloud
+  module Sh
+    class Error < StandardError; end
+    module_function
+
+    def config
+      @config ||= Cloud::Sh::Config.new
+    end
+  end
+end
+
+module Kernel
+  def cloud_sh_exec(*cmd, env: nil)
+    cmd = cmd.flatten.map(&:to_s).join(" ")
+    args = env ? [env, cmd] : [cmd]
+    message = "Executing: #{cmd}"
+    message << " (#{env.inspect})" if env
+    stdout, stderr, status = Open3.capture3(*args)
+    unless status.success?
+      puts "Command: #{cmd}"
+      puts "ENV: #{env.inspect}" if env
+      puts "Stdout:\n#{stdout}\n"
+      puts "Stderr:\n#{stderr}\n"
+      raise "Command failed!!!"
+    end
+    stdout
+  end
+end
+
+class OpenStruct
+  def merge(other)
+    other.each_pair do |k, v|
+      self[k] = v
+    end
+  end
+end

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: cloud-sh
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Cristian Bica
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-08-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gli
+  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'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Cloud shell helpers.
+email:
+- cristian.bica@gmail.com
+executables:
+- cloud-sh
+- kubetail
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/gempush.yml"
+- ".gitignore"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- cloud-sh.gemspec
+- exe/cloud-sh
+- exe/kubetail
+- lib/cloud/sh.rb
+- lib/cloud/sh/cli.rb
+- lib/cloud/sh/commands/base.rb
+- lib/cloud/sh/commands/k8s_exec.rb
+- lib/cloud/sh/commands/k8s_tail.rb
+- lib/cloud/sh/commands/refresh.rb
+- lib/cloud/sh/config.rb
+- lib/cloud/sh/helpers/commands.rb
+- lib/cloud/sh/providers/base.rb
+- lib/cloud/sh/providers/digital_ocean.rb
+- lib/cloud/sh/version.rb
+homepage: https://github.com/cristianbica/cloud-sh
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/cristianbica/cloud-sh
+  source_code_uri: https://github.com/cristianbica/cloud-sh
+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: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Cloud shell helpers.
+test_files: []