sct 0.1.17 → 0.1.22

data/sct/lib/sct.rb

@@ -0,0 +1,17 @@
+require 'sct_core'
+
+require 'sct/version'
+require 'sct/tools'
+
+module Sct
+
+  Helper = SctCore::Helper 
+  UI = SctCore::UI
+
+  class << self 
+    def load_actions
+      # we should load actions here. Something like:
+      # Sct::Actions.load_default_actions
+    end
+  end
+end

data/sct/lib/sct/cli_tools_distributor.rb

@@ -0,0 +1,50 @@
+module Sct
+    class CLIToolsDistributor
+        class << self 
+            def take_off
+                require 'sct'
+
+                tool_name = ARGV.first ? ARGV.first.downcase : nil
+
+                if tool_name && Sct::TOOLS.include?(tool_name.to_sym)
+                    # Triggering a specific tool
+          
+                    require tool_name
+                    begin
+                      # First, remove the tool's name from the arguments
+                      # Since it will be parsed by the `commander` at a later point
+                      # and it must not contain the binary name
+                      ARGV.shift
+          
+                      # Import the CommandsGenerator class, which is used to parse
+                      # the user input
+                      require File.join(tool_name, "commands_generator")
+          
+                      # Call the tool's CommandsGenerator class and let it do its thing
+                      commands_generator = Object.const_get(tool_name.sct_module)::CommandsGenerator
+                    rescue LoadError
+                      # This will only happen if the tool we call here, doesn't provide
+                      # a CommandsGenerator class yet
+                      # When we launch this feature, this should never be the case
+                      abort("#{tool_name} can't be called via `sct #{tool_name}`, run '#{tool_name}' directly instead".red)
+                    end
+          
+                    # Some of the tools might use other actions so need to load all
+                    # actions before we start the tool generator here in the future
+                    Sct.load_actions
+                    
+                    # trigger start on tool
+                    commands_generator.start
+
+                else 
+                    require "sct/commands_generator"
+                    Sct::CommandsGenerator.start
+                end
+            ensure
+                SctCore::UpdateChecker.start_looking_for_update('sct')
+                SctCore::UpdateChecker.show_update_status('sct', Sct::VERSION)
+            end
+
+        end
+    end
+end

data/{lib → sct/lib}/sct/commands/hostfile.rb

@@ -1,28 +1,14 @@
-require 'sct/command_interface'
-
 module Sct
   class HostfileCommand
 
-    IS_PUBLIC_COMMAND = true
-    SYNTAX = 'sct hostfile'
-    SUMMARY = 'adds the ingress url to the users hostfile'
-    DESCRIPTION = ""
-    EXAMPLE = "sct hostfile"
-    EXAMPLE_DESCRIPTION = ""
-
-    OPTIONS = []
-
-    def self.options
-    end
-
     def execute(args, options)
-      return puts "SCT has not been initialized. Run 'sct init' first.".red unless Sct::Config.exists
-
-      return puts "This command needs to be run with sudo.".red unless Sct::Helpers.isSudo
+      return UI.error("SCT has not been initialized. Run 'sct init' first.") unless SctCore::Config.exists
 
-      return unless Sct::Helpers.ingressAddress
+      return UI.error("This command needs to be run with sudo.") unless SctCore::Helper.isSudo
 
-      ingressAddress = Sct::Helpers.ingressAddress
+      return unless SctCore::Helper.ingressAddress
+      
+      ingressAddress = SctCore::Helper.ingressAddress
 
       entries = [
         {
@@ -52,7 +38,7 @@ module Sct
       else
         hosts_paths = ["/etc/hosts"]
 
-        if Sct::Helpers.operatingSystem == Sct::Helpers::WINDOWS
+        if SctCore::Helper.operatingSystem == SctCore::Helper::WINDOWS
           hosts_paths << "/mnt/c/Windows/System32/drivers/etc/hosts"
         end
       end
@@ -72,13 +58,11 @@ module Sct
 
         File.write hosts_path, lines.join
 
-        puts "Patched #{hosts_path} with #{ingressAddress}".green
+        UI.success("Patched #{hosts_path} with #{ingressAddress}")
       end
 
     end
 
-    implements CommandInterface
-
   end
 
 end

data/sct/lib/sct/commands/init.rb

@@ -0,0 +1,37 @@
+require 'sct_core/ui/ui'
+require 'sct_core/config'
+
+module Sct
+
+  class InitCommand
+
+    def execute(args, options)
+
+      dir = SctCore::Config.dir
+
+      cli = HighLine.new
+
+      email = cli.ask("What is your email address?") { |q|
+          q.validate = URI::MailTo::EMAIL_REGEXP
+      }
+
+      cloud_proxy_path = cli.ask("What is the path of your cloud proxy json credentials?") { |q|
+          q.default = "~/.config/gcloud/application_default_credentials.json"
+      }
+
+      contents = ""
+      contents << "email=#{email}\n"
+      contents << "cloud-proxy-path=#{File.expand_path(cloud_proxy_path)}\n"
+
+      if !File.directory?(dir)
+          FileUtils.mkdir_p(dir)
+      end
+
+      File.write(SctCore::Config.path, contents)
+
+      puts "Generated config file at #{SctCore::Config.path}"
+    end
+
+  end
+
+end

data/sct/lib/sct/commands/mysqlproxy.rb

@@ -0,0 +1,20 @@
+module Sct
+  class MysqlproxyCommand
+    
+    DEFAULT_SECRET_NAME = "gcloud-credentials"
+
+    def execute(args, options)
+
+      return UI.error("SCT has not been initialized. Run 'sct init' first.") unless SctCore::Config.exists
+      
+      path = SctCore::Config.get('cloud-proxy-path')
+
+      system("kubectl delete secret gcloud-credentials")
+      system("kubectl create secret generic gcloud-credentials --from-file=#{path}")
+      
+      UI.success("Authenticated with secret-name: '#{DEFAULT_SECRET_NAME}'")
+    end
+  
+  end
+
+end

data/sct/lib/sct/commands_generator.rb

@@ -0,0 +1,56 @@
+require 'commander'
+require 'sct/command'
+
+module Sct
+    class CommandsGenerator
+        include Commander::Methods
+
+        def self.start
+            self.new.run
+        end
+
+        def run 
+            program :name, 'sct'
+            program :version, Sct::VERSION
+            program :summary, 'CLI helper tool for local SCT development'
+            program :description, 'SCT is a CLI tool for developers using the Visma Continuous Deployment Model in conjunction with the Google Cloud Platform (GCP). It provides multiple command to set up and maintain a kubernetes cluster on a machine for local development'
+
+            global_option('--verbose') { $verbose = true }
+
+            command :init do |c| 
+                c.syntax = 'sct init'
+                c.description = 'setup sct'
+
+                c.action do |args, options| 
+                    UI.important("setting up sct")
+                    Sct::InitCommand.new.execute(args, options)
+                end
+            end
+
+            command :hostfile do |c|
+
+                c.syntax = 'sct hostfile'
+                c.description = 'patch hostfile with kubernetes ip'
+
+                c.action do |args, options|
+                    UI.important("Trying to patch hostfile")
+                    Sct::HostfileCommand.new.execute(args, options)
+                end
+            end
+
+            command :'mysql proxy' do |c|
+
+                c.syntax = 'sct mysql proxy'
+                c.description = 'setup google mysql proxy'
+
+                c.action do |args, options| 
+                    UI.important("Trying to setup mysql proxy")
+                    Sct::MysqlproxyCommand.new.execute(args, options)
+                end
+
+            end
+
+            run!
+        end
+    end
+end

data/sct/lib/sct/tools.rb

@@ -0,0 +1,12 @@
+module Sct
+    TOOLS = [
+      :sct,
+      :shell,
+      :cluster
+    ]
+  
+    # a list of all the config files we currently expect
+    TOOL_CONFIG_FILES = [
+      
+    ]
+  end

data/sct/lib/sct/version.rb

@@ -0,0 +1,3 @@
+module Sct
+  VERSION = "0.1.22"
+end

data/sct_core/lib/sct_core.rb

@@ -0,0 +1,14 @@
+require_relative 'sct_core/core_ext/string'
+require_relative 'sct_core/config'
+require_relative 'sct_core/helper'
+require_relative 'sct_core/update_checker/update_checker'
+require_relative 'sct_core/command_executor'
+require_relative 'sct_core/ui/ui'
+require_relative 'sct_core/sct_pty'
+
+# third party code
+require 'colored'
+require 'commander'
+
+# these need to be imported after commander
+require_relative 'sct_core/module'

data/sct_core/lib/sct_core/command_executor.rb

@@ -0,0 +1,104 @@
+require_relative 'ui/ui'
+require_relative 'sct_pty'
+
+module SctCore
+    # Executes commands and takes care of error handling and more
+    class CommandExecutor
+      class << self
+        # Cross-platform way of finding an executable in the $PATH. Respects the $PATHEXT, which lists
+        # valid file extensions for executables on Windows.
+        #
+        #    which('ruby') #=> /usr/bin/ruby
+        #
+        # Derived from https://stackoverflow.com/a/5471032/3005
+        def which(cmd)
+          # PATHEXT contains the list of file extensions that Windows considers executable, semicolon separated.
+          # e.g. ".COM;.EXE;.BAT;.CMD"
+          exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : []
+          exts << '' # Always have an empty string (= no file extension)
+  
+          ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+            exts.each do |ext|
+              cmd_path = File.join(path, "#{cmd}#{ext}")
+              return cmd_path if Helper.executable?(cmd_path)
+            end
+          end
+  
+          return nil
+        end
+  
+        # @param command [String] The command to be executed
+        # @param print_all [Boolean] Do we want to print out the command output while running?
+        # @param print_command [Boolean] Should we print the command that's being executed
+        # @param error [Block] A block that's called if an error occurs
+        # @param prefix [Array] An array containing a prefix + block which might get applied to the output
+        # @param loading [String] A loading string that is shown before the first output
+        # @param suppress_output [Boolean] Should we print the command's output?
+        # @return [String] All the output as string
+        def execute(command: nil, print_all: false, print_command: true, error: nil, prefix: nil, loading: nil, suppress_output: false)
+          print_all = true if $verbose
+          prefix ||= {}
+  
+          output = []
+          command = command.join(" ") if command.kind_of?(Array)
+          command = self.escape_characters_in_string(command)
+          UI.command(command) if print_command
+  
+          if print_all && loading # this is only used to show the "Loading text"...
+            UI.command_output(loading)
+          end
+  
+          begin
+            status = SctCore::SctPty.spawn(command) do |command_stdout, command_stdin, pid|
+              command_stdout.each do |l|
+                line = l.chomp
+                output << line
+  
+                next unless print_all
+  
+                # Prefix the current line with a string
+                prefix.each do |element|
+                  line = element[:prefix] + line if element[:block] && element[:block].call(line)
+                end
+  
+                UI.command_output(line) unless suppress_output
+              end
+            end
+          rescue => ex
+            # SctPty adds exit_status on to StandardError so every error will have a status code
+            status = ex.exit_status
+  
+            # This could happen when the environment is wrong:
+            # > invalid byte sequence in US-ASCII (ArgumentError)
+            output << ex.to_s
+            o = output.join("\n")
+            puts(o)
+            if error
+              error.call(o, nil)
+            else
+              raise ex
+            end
+          end
+  
+          # Exit status for build command, should be 0 if build succeeded
+          if status != 0
+            o = output.join("\n")
+            puts(o) unless suppress_output # the user has the right to see the raw output
+            UI.error("Exit status: #{status}")
+            if error
+              error.call(o, status)
+            else
+              UI.user_error!("Exit status: #{status}")
+            end
+          end
+  
+          return output.join("\n")
+        end
+
+        def escape_characters_in_string(string)
+          pattern = /(\'|\"|\.|\*|\/|\-|\\|\)|\$|\+|\(|\^|\?|\!|\~|\`)/
+          string.gsub(pattern){|match|"\\"  + match}
+        end
+      end
+    end
+  end

data/{lib/sct → sct_core/lib/sct_core}/config.rb

@@ -1,8 +1,8 @@
-module Sct
+module SctCore
     class Config
 
         def self.dir
-            return "#{Sct::Helpers.homePath}/.config/sct"
+            return "#{SctCore::Helper.homePath}/.config/sct"
         end
 
         def self.path
@@ -30,7 +30,7 @@ module Sct
 
             contents = File.read(self.path)
 
-            return Sct::Helpers.to_hash(contents)
+            return SctCore::Helper.to_hash(contents)
         end
     end
 end

data/sct_core/lib/sct_core/core_ext/string.rb

@@ -0,0 +1,9 @@
+class String
+    def sct_class
+      split('_').collect!(&:capitalize).join
+    end
+
+    def sct_module
+        self.sct_class
+    end
+end

data/{lib/sct/setup/helpers.rb → sct_core/lib/sct_core/helper.rb}

@@ -1,5 +1,5 @@
-module Sct
-  class Helpers
+module SctCore
+  class Helper
 
     WINDOWS = "Windows"
     MAC_OS = "MacOS"

data/sct_core/lib/sct_core/sct_pty.rb

@@ -0,0 +1,53 @@
+class StandardError
+    def exit_status
+      return -1
+    end
+  end
+  
+  module SctCore
+    class SctPtyError < StandardError
+      attr_reader :exit_status
+      def initialize(e, exit_status)
+        super(e)
+        set_backtrace(e.backtrace) if e
+        @exit_status = exit_status
+      end
+    end
+  
+    class SctPty
+      def self.spawn(command)
+        require 'pty'
+        PTY.spawn(command) do |command_stdout, command_stdin, pid|
+          begin
+            yield(command_stdout, command_stdin, pid)
+          rescue Errno::EIO
+            # Exception ignored intentionally.
+            # https://stackoverflow.com/questions/10238298/ruby-on-linux-pty-goes-away-without-eof-raises-errnoeio
+            # This is expected on some linux systems, that indicates that the subcommand finished
+            # and we kept trying to read, ignore it
+          ensure
+            begin
+              Process.wait(pid)
+            rescue Errno::ECHILD, PTY::ChildExited
+              # The process might have exited.
+            end
+          end
+        end
+        $?.exitstatus
+      rescue LoadError
+        require 'open3'
+        Open3.popen2e(command) do |command_stdin, command_stdout, p| # note the inversion
+          yield(command_stdout, command_stdin, p.value.pid)
+  
+          command_stdin.close
+          command_stdout.close
+          p.value.exitstatus
+        end
+      rescue StandardError => e
+        # Wrapping any error in SctPtyError to allow
+        # callers to see and use $?.exitstatus that
+        # would usually get returned
+        raise SctPtyError.new(e, $?.exitstatus)
+      end
+    end
+  end