sct 0.1.14 → 0.1.19

data/sct/lib/sct/commands/hostfile.rb

@@ -0,0 +1,68 @@
+module Sct
+  class HostfileCommand
+
+    def execute(args, options)
+      return UI.error("SCT has not been initialized. Run 'sct init' first.") unless SctCore::Config.exists
+
+      return UI.error("This command needs to be run with sudo.") unless SctCore::Helper.isSudo
+
+      return unless SctCore::Helper.ingressAddress
+      
+      ingressAddress = SctCore::Helper.ingressAddress
+
+      entries = [
+        {
+          host: "spend.cloud.local",
+          comment: "The spend cloud ingress url"
+        },
+        {
+          host: "mail.spend.cloud.local",
+          comment: "The spend cloud mail url"
+        },
+        {
+          host: "config.spend.cloud.local",
+          comment: "The spend cloud config url"
+        },
+        {
+          host: "spend-cloud.spend.cloud.local",
+          comment: "The spend cloud web app url"
+        },
+        {
+          host: "docs.spend.cloud.local",
+          comment: "The spend cloud documentation url"
+        }
+      ]
+
+      if options.path
+        hosts_paths = [options.path]
+      else
+        hosts_paths = ["/etc/hosts"]
+
+        if SctCore::Helper.operatingSystem == SctCore::Helper::WINDOWS
+          hosts_paths << "/mnt/c/Windows/System32/drivers/etc/hosts"
+        end
+      end
+
+      hosts_paths.each do |hosts_path|
+        line_ending = hosts_path == "/mnt/c/Windows/System32/drivers/etc/hosts" ? "\r\n" : "\n"
+
+        lines = File.readlines hosts_path
+
+        # select the lines that do not include any entry
+        lines = lines.select { |line| ! entries.any? { |entry| line.include? entry[:host] } }
+
+        # add entries
+        entries.each do |entry|
+          lines << "#{ingressAddress} #{entry[:host]} # #{entry[:comment]}#{line_ending}"
+        end
+
+        File.write hosts_path, lines.join
+
+        UI.success("Patched #{hosts_path} with #{ingressAddress}")
+      end
+
+    end
+
+  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.19"
+end

data/sct_core/lib/sct_core.rb

@@ -0,0 +1,13 @@
+require_relative 'sct_core/core_ext/string'
+require_relative 'sct_core/config'
+require_relative 'sct_core/helper'
+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

data/sct_core/lib/sct_core/ui/implementations/shell.rb

@@ -0,0 +1,129 @@
+require_relative '../interface'
+
+module SctCore
+    # Shell is the terminal output of things
+    # For documentation for each of the methods open `interface.rb`
+    class Shell < Interface
+      require 'tty-screen'
+  
+      def log
+        $stdout.sync = true
+      end
+
+      def writeToUser(message) 
+        puts message
+      end
+  
+      def error(message)
+        writeToUser(message.to_s.red)
+      end
+  
+      def important(message)
+        writeToUser(message.to_s.yellow)
+      end
+  
+      def success(message)
+        writeToUser(message.to_s.green)
+      end
+  
+      def message(message)
+        writeToUser(message.to_s)
+      end
+  
+      def deprecated(message)
+        writeToUser(message.to_s.deprecated)
+      end
+  
+      def command(message)
+        writeToUser("$ #{message}".cyan)
+      end
+  
+      def command_output(message)
+        actual = (message.split("\r").last || "") # as clearing the line will remove the `>` and the time stamp
+        actual.split("\n").each do |msg|  
+            # prefix = msg.include?("▸") ? "" : "▸ "
+            prefix = ""
+            writeToUser(prefix + "" + msg.magenta)
+        end
+      end
+  
+      def verbose(message)
+        message.to_s if $verbose
+      end
+  
+      def header(message)
+        format = format_string
+        if message.length + 8 < TTY::Screen.width - format.length
+          message = "--- #{message} ---"
+          i = message.length
+        else
+          i = TTY::Screen.width - format.length
+        end
+        success("-" * i)
+        success(message)
+        success("-" * i)
+      end
+  
+      def content_error(content, error_line)
+        error_line = error_line.to_i
+        return unless error_line > 0
+  
+        contents = content.split(/\r?\n/).map(&:chomp)
+  
+        start_line = error_line - 2 < 1 ? 1 : error_line - 2
+        end_line = error_line + 2 < contents.length ? error_line + 2 : contents.length
+  
+        Range.new(start_line, end_line).each do |line|
+          str = line == error_line ? " => " : "    "
+          str << line.to_s.rjust(Math.log10(end_line) + 1)
+          str << ":\t#{contents[line - 1]}"
+          error(str)
+        end
+      end
+  
+      #####################################################
+      # @!group Errors: Inputs
+      #####################################################
+  
+      def interactive?
+        interactive = true
+        interactive = false if $stdout.isatty == false
+        return interactive
+      end
+  
+      def input(message)
+        verify_interactive!(message)
+        ask("#{format_string}#{message.to_s.yellow}").to_s.strip
+      end
+  
+      def confirm(message)
+        verify_interactive!(message)
+        agree("#{format_string}#{message.to_s.yellow} (y/n)", true)
+      end
+  
+      def select(message, options)
+        verify_interactive!(message)
+  
+        important(message)
+        choose(*options)
+      end
+  
+      def password(message)
+        verify_interactive!(message)
+  
+        ask("#{format_string}#{message.to_s.yellow}") { |q| q.echo = "*" }
+      end
+
+      def user_error!(error_message, options = {})
+        writeToUser(error_message.yellow)
+      end
+  
+      private
+  
+      def verify_interactive!(message)
+        return if interactive?
+        important(message)
+        crash!("Could not retrieve response as sct runs in non-interactive mode")
+      end
+    end
+  end