sct 0.1.28 → 0.1.29

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2795077123ba193f891933659f88c61cb4a986ebc4a5c7bf8ced2fd9b9b54a97
-  data.tar.gz: 8478af6c3a869f524b09bc607ae09acbc48eed401777366947fc270a39166a2b
+  metadata.gz: d96c99f55b060e2403cbc2e63dc4559bb14bb7fe7a3204c30c50591688a9ea3c
+  data.tar.gz: fe5f3c027f2a334a83f31fc9ab11c43f85898db0fb1d04395bbb74fdd14b74ec
 SHA512:
-  metadata.gz: deecf2931622dda191ee00ffc6412a41c7aa4ac8df88006f8eeab183c8d50c543fb2d25f5012c47157f0faa1208431d450716e9b6f50506991aaa1a5f3e95dbc
-  data.tar.gz: afcf8914cbd3efba0e46764b5ed8633f570ec2e9b272a70a28cf48d11fd29bd41beaa1b9cd4896a263f99d657835fccb5329a245a160a009a47f17a4915589cb
+  metadata.gz: 4608475ca7570f3422afc13eaf43c0d8429304e667e688ebfa90a3bc26f168a062e45122d22794615c1824a740dbcb501bc9f0b6175083a60dbc6b89606d5a25
+  data.tar.gz: 8a5c1afac5d76c0fb820ee84d1edd9896a6c5bb51be0359600d4202bba035d1052ae18a1ffd6e9870e7c285952b230ecbf8e9dda6f2970e67ca2154b61ae1766

data/cluster/lib/cluster/commands_generator.rb

@@ -9,74 +9,71 @@ module Cluster
             self.new.run
         end
 
-        def run 
+        def run
             program :name, 'cluster'
             program :version, Sct::VERSION
             program :description, 'CLI for \'cluster\' - Manage your local kubernetes cluster'
 
             global_option('--verbose') { $verbose = true }
 
-            command :up do |c|
+            command :start do |c|
+                c.syntax = "sct cluster start"
+                c.description = "start the cluster"
 
-                c.syntax = "sct cluster up"
-                c.description = "Start the cluster"
-                c.option '--clean', 'start a clean cluster. Old cluster will be purged if available.'
-
-                c.action do |args, options| 
-                    if options.clean 
-                        Cluster::Runner.new.reset
-                    else
-                        Cluster::Runner.new.launch
-                    end
+                c.action do |args, options|
+                    Cluster::Runner.new.start
                 end
 
             end
 
-            command :down do |c|
-
-                c.syntax = 'sct cluster down'
+            command :stop do |c|
+                c.syntax = 'sct cluster stop'
                 c.description = 'stop the cluster'
 
-                c.action do |args, options| 
-                    Cluster::Runner.new.down
+                c.action do |args, options|
+                    Cluster::Runner.new.stop
                 end
             end
 
             command :restart do |c|
-
-                c.syntax = 'sct cluster restart'
-                c.description = 'restart the cluster (this is a short hand for sct cluster down && sct cluster up)'
+                c.syntax = "sct cluster restart"
+                c.description = "restart the cluster"
 
                 c.action do |args, options|
-                    Cluster::Runner.new.down
-                    Cluster::Runner.new.launch
+                    Cluster::Runner.new.restart
                 end
+
             end
 
-            command :reset do |c| 
+            command :delete do |c|
+                c.syntax = "sct cluster delete"
+                c.description = "delete the cluster"
 
+                c.action do |args, options|
+                    Cluster::Runner.new.delete
+                end
+
+            end
+
+            command :reset do |c|
                 c.syntax = 'sct cluster reset'
-                c.description = 'reset your cluster and start with a clean cluster'
+                c.description = 'delete the cluster and start a new cluster'
 
-                c.action do |args, options| 
+                c.action do |args, options|
                     Cluster::Runner.new.reset
                 end
             end
 
-            alias_command :'setup', :'reset'
-
             command :status do |c|
-
                 c.syntax = 'sct cluster status'
                 c.description = 'see the status of your cluster'
 
-                c.action do |args, options| 
+                c.action do |args, options|
                     Cluster::Runner.new.status
                 end
             end
 
             command :'update config' do |c|
-                
                 c.syntax = 'sct cluster update config'
                 c.description = 'update the cluster configuration'
 
@@ -85,36 +82,16 @@ module Cluster
                 end
             end
 
-            command :'delete pods' do |c|
-                c.syntax = 'sct cluster delete stalled pods'
-                c.description = 'delete stalled pods from the cluster'
-                c.option '--stalled', 'delete stalled pods'
-                c.option '--all', 'delete all pods'
-
-                c.action do |args, options|
-
-                    Cluster::Runner.new.delete_stalled_pods if options.stalled
-                    Cluster::Runner.new.delete_all_pods if options.all
-                    
-                    Cluster::Runner.new.delete_pods(args) if !args.empty?
-
-                end
-            end
-
-            command :'apply pods' do |c|
-                c.syntax = 'sct cluster apply pods'
-                c.description = 'apply pods from the k8s folder'
+            command :'apply deployments' do |c|
+                c.syntax = 'sct cluster apply deployments'
+                c.description = 'apply deployments from the k8s folder'
 
                 c.action do |args, options|
-
-                    Cluster::Runner.new.apply_pods
-
+                    Cluster::Runner.new.apply_deployments
                 end
             end
 
-            default_command :status
-
             run!
         end
     end
-end
+end

data/cluster/lib/cluster/module.rb

@@ -2,6 +2,6 @@ module Cluster
 
     # import the helper functionality from SCT
     Helpers = Sct::Helper
-    UI = Sct::UI 
+    UI = Sct::UI
 
-end
+end

data/cluster/lib/cluster/runner.rb

@@ -1,118 +1,157 @@
 module Cluster
     class Runner
 
-        def launch
-            return UI.error("SCT has not been initialized. Run 'sct init' first.") unless SctCore::Config.exists
+        def start
+            SctCore::Helper.ensure_windows_administrator # "sct hostfile" will need it later on
+
+            existing_cluster = cluster_exists?
+
             start_cluster
-            run_command "kubectl delete pod -n kube-system #{pods("kube-system").map { |pod| pod[:name] if pod[:name].start_with? "registry-creds" } .compact.join(" ")}"
-            run_command "kubectl rollout status -n kube-system deployment/registry-creds"
+
+            if existing_cluster
+                run_command "kubectl rollout restart -n kube-system deployment registry-creds"
+                run_command "kubectl rollout status -n kube-system deployment registry-creds"
+            else
+                create_secrets
+                enable_addons
+                wait_for_gcr_secret
+                run_command "kubectl apply -f ~/development/spend-cloud/k8s/ingress.yml"
+                wait_for_ingress_ip
+                run_command "kubectl apply -f ~/development/spend-cloud/k8s/dependencies.yml"
+                wait_for_pods
+                run_command "kubectl apply -f ~/development/spend-cloud/k8s/"
+            end
+
             post_start
         end
 
+        def stop
+            run_command "minikube stop"
+        end
+
+        def restart
+            SctCore::Helper.ensure_windows_administrator # "sct hostfile" will need it later on
+
+            stop
+            start
+        end
+
+        def delete
+            run_command "minikube delete"
+        end
+
+        def reset
+            SctCore::Helper.ensure_windows_administrator # "sct hostfile" will need it later on
+
+            delete
+            start
+        end
+
+        def status
+            print_contexts
+            print_minikube_status
+
+            if get_minikube_status.find_all { |status| status[1] == 'Stopped' }.count == 0
+              print_pods_status("kube-system")
+              print_pods_status
+            else
+              UI.important("Please check your minikube status. If all services are stopped you should start the minikube first.")
+            end
+        end
+
+        def update_config
+            run_command "kubectl config use-context minikube"
+
+            run_command "kubectl replace -n kube-system -f #{File.expand_path('resources/corefile.yml', __dir__)}"
+            run_command "kubectl rollout restart -n kube-system deployment coredns"
+            run_command "kubectl rollout status -n kube-system deployment coredns"
+        end
+
+        def apply_deployments
+            run_command "kubectl apply -f ~/development/spend-cloud/k8s/"
+        end
+
+
+        def cluster_exists?
+            if system "minikube status", { out: "/dev/null" }
+                # cluster exists and is running
+                return true
+            end
+
+            if $?.exitstatus == 85
+                # cluster does not exist
+                return false
+            end
+
+            # cluster exists but is stopped
+            return true
+        end
+
         def start_cluster
             if SctCore::Helper.operatingSystem == SctCore::Helper::MAC_OS
-                run_command "#{SctCore::Helper.minikube} start --cpus=$(sysctl -n hw.ncpu) --memory=8G"
+                run_command "minikube start --driver=docker --cpus=$(sysctl -n hw.ncpu) --memory=8G"
             else
-                run_command "#{SctCore::Helper.minikube} start --cpus=$(cat /proc/cpuinfo | grep processor | wc -l) --memory=10G"
+                run_command "minikube start --driver=docker --cpus=$(cat /proc/cpuinfo | grep processor | wc -l) --memory=3G"
             end
-            run_command "#{SctCore::Helper.minikube} ssh -- 'sudo su -c \"echo 10048576 > /proc/sys/fs/inotify/max_user_watches\"'"
             update_config
         end
 
         def post_start
             wait_for_pods
             run_command "sudo sct hostfile"
+            run_command "minikube tunnel &", { out: "/dev/null", err: "/dev/null" } if SctCore::Helper::is_windows? # leave this running detached forever in the background
             UI.success("\n✔️ You can visit your environment at 👉 https://spend-cloud.spend.cloud.local 👌")
         end
 
-        def down
-            run_command "#{SctCore::Helper.minikube} stop"
-        end
-
-        def reset
-            run_command "#{SctCore::Helper.minikube} delete"
-            start_cluster
-            create_secrets
-            enable_addons
-            wait_for_gcr_secret
-            run_command "kubectl apply -f ~/development/spend-cloud/k8s/ingress.yml"
-            wait_for_ingress_ip
-            run_command "kubectl apply -f ~/development/spend-cloud/k8s/dependencies.yml"
-            wait_for_pods
-            run_command "kubectl apply -f ~/development/spend-cloud/k8s/"
-            post_start
-        end
-
         def enable_addons
             enable_addon "registry-creds"
             enable_addon "ingress"
         end
 
         def enable_addon(addon)
-            run_command "#{SctCore::Helper.minikube} addons enable #{addon}"
+            run_command "minikube addons enable #{addon}"
 
             deployment = deployments("kube-system").find { |deployment| deployment[:name].include? addon }
 
-            run_command "kubectl rollout status -n kube-system deployment/#{deployment[:name]}"
+            run_command "kubectl rollout status -n kube-system deployment #{deployment[:name]}"
         end
 
         def wait_for_pods
             UI.important("Waiting for pods to become ready...")
 
-            while ! pods.all? { |pod| pod[:status] == "Running" }
-                delete_stalled_pods
-
-                sleep 5
-            end
-
-            UI.success("Pods are now ready.")
-        end
-
-        def delete_stalled_pods(feedback: false)
-
-            return UI.success("No stalled pods found") unless !pods.to_a.empty?
-
-            stalled_pods = pods.select { |pod| pod[:stalled] }
+            previous_lines = 0
 
-            if stalled_pods.empty?
-                UI.success("There are no stalled pods.") if feedback
-            else
-                run_command "kubectl delete pods #{stalled_pods.map { |pod| pod[:name] } .join(" ")}"
-            end
-        end
+            while ! pods.all? { |pod| pod[:ready] }
+                pods_status_lines = get_pods_status.to_s.lines.map { |line| line.chomp }
 
-        def delete_all_pods
-            run_command "kubectl delete pods --all"
-        end
+                current_lines = pods_status_lines.length
 
-        def delete_pods(args)
-            run_command "kubectl delete pods #{args.join(" ")}"
-        end
+                line_difference = current_lines - previous_lines
 
-        def apply_pods
-            run_command "kubectl apply -f ~/development/spend-cloud/k8s/"
-        end
+                if line_difference < 0 # there are now less lines than before
+                    line_difference.abs.times do
+                        print "\033[1A\033[K" # move the cursor up a line and clear the line
+                    end
 
-        def update_config
-            if SctCore::Helper.operatingSystem == SctCore::Helper::WINDOWS
-                windows_home_path = SctCore::Helper.windowsHomePath
-                kube_file_path = windows_home_path+"/.kube/config"
+                    print "\033[#{current_lines}A" # move the cursor all the way up to the start of the table
+                elsif previous_lines > 0
+                    print "\033[#{previous_lines}A" # move the cursor all the way up to the start of the table
+                end
 
-                if !File.exists?(kube_file_path)
-                    return UI.error("#{kube_file_path} doesn't exist")
+                pods_status_lines.each do |line|
+                    print "#{line}\033[K#{$/}" # print the content of the line, clear remaining characters and add a new line
                 end
 
-                run_command "sed -e 's~\\\\~/~g' -e 's~C:~/mnt/c~g' < #{kube_file_path} > ~/.kube/minikube-config"
+                previous_lines = current_lines
 
-                UI.success("#{kube_file_path} copied to ~/.kube/minikube-config")
+                sleep 5
             end
 
-            run_command "kubectl config use-context minikube"
+            previous_lines.times do
+                print "\033[1A\033[K" # move the cursor up a line and clear the line
+            end
 
-            run_command "kubectl replace -n kube-system -f #{File.expand_path('resources/corefile.yml', __dir__)}"
-            old_list = pods("kube-system").map { |pod| pod[:name] if pod[:name].start_with? "coredns" }.compact
-            run_command "kubectl delete pod -n kube-system #{old_list.join(" ")}" unless old_list.to_a.empty?
-            run_command "kubectl rollout status -n kube-system deployment/coredns"
+            UI.success("Pods are now ready.")
         end
 
         def deployments(namespace = "default")
@@ -150,13 +189,15 @@ module Cluster
                 columns = line.split(" ")
 
                 name = columns[0]
+                ready = columns[1].split("/").reduce { |l, r| l == r }
+                replicas = columns[1]
                 status = columns[2]
-                stalled = status == "ErrImagePull" || status == "ImagePullBackOff"
 
                 {
                     name: name,
-                    status: status,
-                    stalled: stalled
+                    ready: ready,
+                    replicas: replicas,
+                    status: status
                 }
             end
         end
@@ -193,18 +234,6 @@ module Cluster
             UI.success("Ingress IP is now available.")
         end
 
-        def status
-            print_contexts
-            print_minikube_status
-
-            if get_minikube_status.find_all { |status| status[1] == 'Stopped' }.count == 0
-              print_pods_status("kube-system")
-              print_pods_status
-            else
-              UI.important("Please check your minikube status. If all services are stopped you should start the minikube first.")
-            end
-        end
-
         def print_contexts
           output = `kubectl config get-contexts`
 
@@ -223,12 +252,11 @@ module Cluster
         end
 
         def print_minikube_status
-
           puts Terminal::Table.new title: "Minikube status".green, headings: ['Name', 'Status'], rows: get_minikube_status
         end
 
         def get_minikube_status
-          output = `#{SctCore::Helper.minikube} status`
+          output = `minikube status`
 
           lines = output.split "\n"
 
@@ -240,25 +268,32 @@ module Cluster
         end
 
         def print_pods_status(namespace = "default")
+            output = get_pods_status(namespace)
 
-          pods_list = pods(namespace)
+            puts output if output
+        end
 
-          if pods_list.to_a.empty?
-            return
-          end
+        def get_pods_status(namespace = "default")
+          rows = pods(namespace).map do |pod|
+            status = pod[:status]
+            replicas = pod[:replicas]
 
-          rows = pods_list.map do |pod|
             [
                 pod[:name],
-                pod[:status] == "Running" ? pod[:status].green : pod[:status].red
+                status == "Running" ? status.green : status.red,
+                pod[:ready] ? replicas.green : replicas.red
             ]
           end
 
-          puts Terminal::Table.new title: "Pods (namespace: #{namespace})".green, headings: ['Name', 'Status'], rows: rows
+          if rows.empty?
+            return
+          end
+
+          return Terminal::Table.new title: "Pods (namespace: #{namespace})".green, headings: ['Name', 'Status', 'Replicas ready'], rows: rows
         end
 
-        def run_command command
-            if ! system command
+        def run_command command, options = {}
+            if ! system command, options
                 raise command.red
             end
         end

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

@@ -2,13 +2,7 @@ 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
+      SctCore::Helper.ensure_permissions
 
       entries = [
         {
@@ -37,32 +31,42 @@ module Sct
         }
       ]
 
+      is_windows = SctCore::Helper::is_windows?
+
+      if is_windows
+        ingress_address = "127.0.0.1"
+      else
+        ingress_address = `sudo -u $SUDO_USER minikube ip`.chomp
+      end
+
+      windows_hosts_path = "/mnt/c/Windows/System32/drivers/etc/hosts"
+
       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"
+        if is_windows
+          hosts_paths << windows_hosts_path
         end
       end
 
       hosts_paths.each do |hosts_path|
-        line_ending = hosts_path == "/mnt/c/Windows/System32/drivers/etc/hosts" ? "\r\n" : "\n"
+        line_ending = hosts_path == windows_hosts_path ? "\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] } }
+        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}"
+          lines << "#{ingress_address} #{entry[:host]} # #{entry[:comment]}#{line_ending}"
         end
 
         File.write hosts_path, lines.join
 
-        UI.success("Patched #{hosts_path} with #{ingressAddress}")
+        UI.success("Patched #{hosts_path} with #{ingress_address}")
       end
 
     end

data/sct/lib/sct/commands_generator.rb

@@ -9,7 +9,7 @@ module Sct
             self.new.run
         end
 
-        def run 
+        def run
             program :name, 'sct'
             program :version, Sct::VERSION
             program :summary, 'CLI helper tool for local SCT development'
@@ -17,11 +17,11 @@ module Sct
 
             global_option('--verbose') { $verbose = true }
 
-            command :init do |c| 
+            command :init do |c|
                 c.syntax = 'sct init'
                 c.description = 'setup sct'
 
-                c.action do |args, options| 
+                c.action do |args, options|
                     UI.important("setting up sct")
                     Sct::InitCommand.new.execute(args, options)
                 end
@@ -33,17 +33,17 @@ module Sct
                 c.description = 'patch hostfile with kubernetes ip'
 
                 c.action do |args, options|
-                    UI.important("Trying to patch hostfile")
+                    UI.important("Trying to patch hosts file...")
                     Sct::HostfileCommand.new.execute(args, options)
                 end
             end
 
-            command :'mysql proxy' do |c|
+            command :'mysql-proxy' do |c|
 
-                c.syntax = 'sct mysql proxy'
+                c.syntax = 'sct mysql-proxy'
                 c.description = 'setup google mysql proxy'
 
-                c.action do |args, options| 
+                c.action do |args, options|
                     UI.important("Trying to setup mysql proxy")
                     Sct::MysqlproxyCommand.new.execute(args, options)
                 end
@@ -67,4 +67,4 @@ module Sct
             run!
         end
     end
-end
+end

data/sct/lib/sct/version.rb

@@ -1,3 +1,3 @@
 module Sct
-  VERSION = "0.1.28"
+  VERSION = "0.1.29"
 end

data/sct_core/lib/sct_core/helper.rb

@@ -5,27 +5,6 @@ module SctCore
     MAC_OS = "MacOS"
     UBUNTU = "Ubuntu"
 
-    def self.ingressAddress
-      if self.operatingSystem == WINDOWS
-        kubeconfig_file = "minikube-config"
-      else
-        kubeconfig_file = "config"
-      end
-
-      kubeconfig_path= "#{self.homePath}/.kube/#{kubeconfig_file}"
-
-      ip = `KUBECONFIG="#{kubeconfig_path}" kubectl get ingress`
-
-      if ip.nil? || ip.empty?
-        puts "Can't fetch IP from kubectl".yellow
-        return nil
-      end
-
-      match = ip.scan(/((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3})/)
-
-      return match.first.first
-    end
-
     def self.to_hash(str)
       Hash[
         str.split("\n").map{|i|i.split('=')}
@@ -60,7 +39,7 @@ module SctCore
     end
 
     def self.windowsHomePath
-      if self.operatingSystem == WINDOWS
+      if self.is_windows?
         return self.convertWindowsToWSLPath(`cmd.exe /c echo %userprofile%`)
       end
 
@@ -68,7 +47,7 @@ module SctCore
     end
 
     def self.convertWindowsToWSLPath(path)
-      if self.operatingSystem == WINDOWS
+      if self.is_windows?
         return path.gsub(/C:\\/, '/mnt/c/').gsub(/\\\\/, "/").gsub(/\\/, '/').gsub(/\r\n?/, '')
       end
 
@@ -76,23 +55,43 @@ module SctCore
     end
 
     def self.convertWSLToWindowsPath(path)
-      if self.operatingSystem == WINDOWS
+      if self.is_windows?
         return path.gsub(/\/mnt\/c/, 'C:/').gsub(/\/\//, '/').gsub(/\\\\/, "/").gsub(/\r\n?/, '')
       end
 
       return path
     end
 
-    def self.isSudo
+    def self.is_sudo?
       return !ENV["SUDO_USER"].nil? && !ENV["SUDO_USER"].empty?
     end
 
-    def self.minikube
-      if self.operatingSystem == WINDOWS
-          return "minikube.exe"
-      else
-          return "minikube"
+    def self.is_windows?
+      return self.operatingSystem == WINDOWS
+    end
+
+    def self.is_windows_administrator?
+      # https://serverfault.com/a/95464
+      return `/mnt/c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe -c "(New-Object Security.Principal.WindowsPrincipal([Security.Principal.WindowsIdentity]::GetCurrent())).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)"` == "True\r\n"
+    end
+
+    def self.ensure_sudo
+      if !self.is_sudo?
+        UI.error "This command needs to be run with sudo."
+        exit 1
       end
     end
+
+    def self.ensure_windows_administrator
+      if self.is_windows? && !self.is_windows_administrator?
+        UI.error "This command needs to be run in an admin shell."
+        exit 1
+      end
+    end
+
+    def self.ensure_permissions
+      self.ensure_sudo
+      self.ensure_windows_administrator
+    end
   end
 end

data/sct_core/lib/sct_core/update_checker/update_checker.rb

@@ -38,11 +38,7 @@ module SctCore
                 UI.important("# An update for #{gem_name} is available. You are on #{current_version}.")
             end
             UI.important("# You should use the latest version.")
-            UI.important("# Please update using `#{self.update_command(gem_name: gem_name)}`.")
-
-            UI.important('#######################################################################')
-            UI.important("# Run `sudo gem cleanup` from time to time to speed up sct.")
-
+            UI.important("# Please update by running `#{self.update_command(gem_name: gem_name)}`.")
             UI.important('#######################################################################')
 
             ensure_rubygems_source
@@ -62,7 +58,7 @@ module SctCore
         end
 
         def self.update_command(gem_name: "sct")
-            "sudo gem install #{gem_name.downcase}"
+            "sudo gem update #{gem_name.downcase}"
         end
 
         def self.fetch_latest(gem_name)

data/shell/lib/shell.rb

@@ -1,3 +1,2 @@
-require_relative 'shell/tools'
 require_relative 'shell/runner'
-require_relative 'shell/module'
+require_relative 'shell/module'

data/shell/lib/shell/commands_generator.rb

@@ -7,8 +7,8 @@ module Shell
             self.new.run
         end
 
-        def run 
+        def run
             Shell::Runner.new.launch
         end
     end
-end
+end

data/shell/lib/shell/module.rb

@@ -4,6 +4,6 @@ module Shell
 
     # import the helper functionality from SCT
     Helpers = Sct::Helper
-    UI = Sct::UI 
+    UI = Sct::UI
 
-end
+end

data/shell/lib/shell/runner.rb

@@ -1,34 +1,83 @@
+require 'yaml'
+
 module Shell
     class Runner
-        # define launch work
-        def launch 
-
-            tool_name = ARGV.first ? ARGV.first.downcase : nil
-
-            if tool_name && Shell::TOOLS.include?(tool_name.to_sym)
-                
-                require_relative "docker/#{tool_name}"
-                command = "#{ARGV[1..(ARGV.length+1)].join(" ")}"
-
-                case ARGV.first
-                when 'php'
-                    Shell::Php.exec(command)
-                when 'composer'
-                    Shell::Composer.exec(command)
-                when 'yarn'
-                    Shell::Yarn.exec(command)
-                else
-                    show_error
-                end
-                
+
+        def launch
+            command = ARGV.join(" ")
+
+            if ! File.exist? "./okteto.yml"
+                error "Could not find file 'okteto.yml'."
+            end
+
+            manifest = YAML.load File.read "./okteto.yml"
+
+            deployment = manifest["name"]
+
+            pod = find_pod deployment
+
+            if command.empty?
+                system "kubectl exec #{pod} -it -- sh", { in: :in, out: :out, err: :err }
             else
-                show_error
+                system "kubectl exec #{pod} -it -- #{command}", { in: :in, out: :out, err: :err }
+            end
+        end
+
+        def find_pod deployment
+            output = `kubectl get pods --show-labels`
+
+            # split output lines
+            lines = output.split "\n"
+
+            #  exclude first line (table header)
+            lines = lines[1..-1]
+
+            # get the name and labels of each pod
+            pods = lines.map do |line|
+                columns = line.split " "
+
+                name = columns[0]
+
+                labels = columns[5].split(",").reduce({}) do |labels, label|
+                    key, value = label.split "="
+                    labels[key] = value
+                    labels
+                end
+
+                {
+                    name: name,
+                    labels: labels
+                }
             end
+
+            # filter by deployment
+            pods = pods.filter { |pod| pod[:labels]["app"] == deployment }
+
+            if pods.length == 0
+                error "Could not find pod for deployment #{deployment}."
+            elsif pods.length > 1
+                error "Found more than one pod for deployment #{deployment}. Multiple pods are not supported."
+            end
+
+            pod = pods.first
+
+            if pod[:labels]["dev.okteto.com"] != "true"
+                print "The current pod is running a production image and was not started by Okteto. Are you sure you want to continue? [y/N] ".red
+
+                answer = $stdin.readline.chomp.downcase
+
+                if answer != "y"
+                    exit
+                end
+            end
+
+            pod[:name]
         end
 
-        def show_error 
-            tools = Shell::TOOLS.map { |tool| tool.to_s }.join(", ")
-            UI.error("Tool not found. Try one of these: #{tools}")
+        def error message
+            UI.error message
+            exit 1
         end
+
     end
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sct
 version: !ruby/object:Gem::Version
-  version: 0.1.28
+  version: 0.1.29
 platform: ruby
 authors:
 - Reshad Farid
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-10-15 00:00:00.000000000 Z
+date: 2020-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colored
@@ -227,17 +227,10 @@ files:
 - sct_core/lib/sct_core/ui/interface.rb
 - sct_core/lib/sct_core/ui/ui.rb
 - sct_core/lib/sct_core/update_checker/update_checker.rb
-- shell/README.md
 - shell/lib/shell.rb
-- shell/lib/shell/ClassLevelInheritableAttributes.rb
 - shell/lib/shell/commands_generator.rb
-- shell/lib/shell/docker/composer.rb
-- shell/lib/shell/docker/docker.rb
-- shell/lib/shell/docker/php.rb
-- shell/lib/shell/docker/yarn.rb
 - shell/lib/shell/module.rb
 - shell/lib/shell/runner.rb
-- shell/lib/shell/tools.rb
 homepage: https://gitlab.com/proactive-software/packages/sct
 licenses:
 - MIT

data/shell/lib/shell/ClassLevelInheritableAttributes.rb

@@ -1,25 +0,0 @@
-module ClassLevelInheritableAttributes
-  def self.included(base)
-    base.extend(ClassMethods)
-  end
-
-  module ClassMethods
-    def inheritable_attributes(*args)
-      @inheritable_attributes ||= [:inheritable_attributes]
-      @inheritable_attributes += args
-      args.each do |arg|
-        class_eval %(
-          class << self; attr_accessor :#{arg} end
-        )
-      end
-      @inheritable_attributes
-    end
-
-    def inherited(subclass)
-      @inheritable_attributes.each do |inheritable_attribute|
-        instance_var = "@#{inheritable_attribute}"
-        subclass.instance_variable_set(instance_var, instance_variable_get(instance_var))
-      end
-    end
-  end
-end

data/shell/lib/shell/docker/composer.rb

@@ -1,16 +0,0 @@
-require "sct_core"
-require_relative "docker"
-
-module Shell
-    class Composer < Docker
-
-        # Configure the Yarn command
-       def self.config
-            self.set_image("eu.gcr.io/dev-pasc-vcdm/helpers-composer:latest", true)
-            self.set_pwd_as_volume("/app")
-            self.add_volume(SctCore::Helper.convertWSLToWindowsPath("#{SctCore::Helper.windowsHomePath || SctCore::Helper.homePath}/.composer") , "/tmp")
-            self.set_current_user_and_group()
-            self.set_entrypoint("composer")
-        end
-    end
-end

data/shell/lib/shell/docker/docker.rb

@@ -1,218 +0,0 @@
-require "sct_core"
-require "shell/ClassLevelInheritableAttributes"
-
-module Shell
-    class Docker
-        include ClassLevelInheritableAttributes
-        inheritable_attributes :image, :is_private_registry, :entrypoint, :volumes, :ports, :extra_arguments, :env_variables
-
-        @image = nil
-        @is_private_registry = false
-        @entrypoint = nil
-
-        @volumes = {}
-        @ports = {}
-        @user_group = []
-        @extra_arguments = {}
-        @env_variables = {}
-
-        ###
-        # The Docker command configuration. This has to be able to execute the command properly
-        ###
-        def self.config
-            # Run some initialization commands
-        end
-
-        ###
-        # Execute the configured command
-        ###
-        def self.exec(cli_arguments)
-
-            self.add_extra_argument(cli_arguments)
-
-            self.config
-
-            # Check if the basic variables are set
-            if !@image || @image.empty?
-                raise LoadError, "The required image is not defined for this command"
-            end
-
-            if !self.check_for_image && @is_private_registry
-                unless self.login_to_private_registry
-                    raise RuntimeError, "Could not authenticate to GCR (" + $?.exitstatus + ")"
-                end
-            end
-
-            self.run_command
-        end
-
-        ###
-        # The image for this Docker command
-        ###
-        def self.set_image(image, is_private_registry=false)
-            @image = image
-            @is_private_registry = is_private_registry
-        end
-
-        ###
-        # Set the current PWD as a volume on the specified path in the container
-        ###
-        def self.set_pwd_as_volume(volume_path)
-            pwd = `pwd -P`
-
-            if SctCore::Helper.operatingSystem == SctCore::Helper::WINDOWS
-                pwd=SctCore::Helper.convertWSLToWindowsPath(pwd)
-            end
-
-            add_volume(pwd, volume_path)
-        end
-
-        ###
-        # Add an extra volume in the container
-        ###
-        def self.add_volume(local_path, volume_path)
-            @volumes[local_path] = volume_path
-        end
-
-        ###
-        # Add a port mapping for the container
-        ###
-        def self.map_port(external_port, container_port = nil)
-
-            external_port=String(external_port)
-            container_port=String(container_port)
-
-            if container_port.empty?
-                container_port = external_port
-            end
-
-            @ports[external_port] = container_port
-        end
-
-        ###
-        # Set the current user and group in the container
-        ###
-        def self.set_current_user_and_group
-            @user_group = []
-            @user_group << `id -u`
-            @user_group << `id -g`
-        end
-
-        ###
-        # Set the entrypoint for the command in the container
-        ###
-        def self.set_entrypoint(entrypoint)
-            @entrypoint=entrypoint
-        end
-
-        ###
-        # Add extra arguments to be configured for the container
-        ###
-        def self.add_extra_argument(argument, value=nil)
-            argument = String(argument)
-
-            if value
-                value = String(value)
-            end
-
-            self.extra_arguments[argument] = value
-        end
-
-        ###
-        # Set environment variables for the container
-        ###
-        def self.set_environment_variables(env_variables)
-            @env_variables = env_variables
-        end
-
-        ###
-        # Check if the image is already present in the system
-        ###
-        def self.check_for_image
-            image_list=`docker images -q #{@image} 2> /dev/null`
-
-            return image_list && !image_list.empty?
-        end
-
-        ###
-        # Login to the private container registry with the cloud credentials
-        ###
-        def self.login_to_private_registry
-            `docker login -u oauth2accesstoken -p "$(gcloud auth application-default print-access-token)" https://eu.gcr.io &> /dev/null`
-            return $?.success?
-        end
-
-        ###
-        # Run the command
-        ###
-        def self.run_command
-            command = self.compile_command
-
-            SctCore::CommandExecutor.execute(command: command, print_all: true, suppress_output: false)
-        end
-
-        ###
-        # Compile the command with all options
-        ###
-        def self.compile_command
-            # Basic docker run command
-            command = self.add_to_command_string("" , "docker run --rm -it")
-
-            # Attach environment variables
-            if @env_variables
-                @env_variables.each do |key, value|
-                    if value && !value.empty?
-                        command  = self.add_to_command_string(command, "-e " + key+"="+value)
-                    else
-                        command  = self.add_to_command_string("-e " + key, value)
-                    end
-                end
-            end
-
-            # Attach configured volumes
-            if @volumes
-                @volumes.each do |local_path, container_path|
-                    command = self.add_to_command_string(command, "--volume " + local_path +":"+ container_path)
-                end
-            end
-
-            # Map configured ports
-            if @ports
-                @ports.each do |external_port, container_port|
-                    command = self.add_to_command_string(command, "-p " + external_port +":"+ container_port)
-                end
-            end
-
-            if @user_group
-                command  = self.add_to_command_string(command, "--user "+ String(@user_group.shift) +":"+ String(@user_group.shift))
-            end
-
-            # Add image to command
-            command  = self.add_to_command_string(command, @image)
-
-            if @entrypoint
-                command  = self.add_to_command_string(command, String(@entrypoint))
-            end
-
-            # Append arguments and options to command
-            if @extra_arguments
-                @extra_arguments.each do |argument, value|
-                    if value && !value.empty?
-                        command  = self.add_to_command_string(command, argument+"="+value)
-                    else
-                        command  = self.add_to_command_string(command, argument)
-                    end
-                end
-            end
-
-            return command
-        end
-
-        ###
-        # Append a part to the command string and remove any unwanted characters
-        ###
-        def self.add_to_command_string(command_string, append)
-            return command_string + append.gsub(/\r?\n/, "") + " "
-        end
-    end
-end

data/shell/lib/shell/docker/php.rb

@@ -1,60 +0,0 @@
-require "sct_core"
-
-require_relative "docker"
-
-module Shell
-  class Php < Docker
-
-    attr_accessor :make
-
-    # Configure the Yarn command
-    def self.config
-      self.set_image("eu.gcr.io/dev-pasc-vcdm/proactive-base:latest", true)
-      self.set_pwd_as_volume("/var/www")
-      self.set_current_user_and_group
-      self.set_entrypoint("php")
-      self.set_environment_variables(self.get_environment_variables)
-    end
-
-    def self.get_environment_variables
-      environment_variables = {}
-      environment_variables.store("ENVIRONMENT", "local")
-
-      environment_variables = self.add_service_ip_and_port(environment_variables)
-
-      return environment_variables
-    end
-
-    def self.add_service_ip_and_port(environment_variables)
-      service_names = %w[mysql-service redis-service]
-
-      minikube_status
-
-      service_names.each { |service_name|
-        url = `#{SctCore::Helper.minikube} service #{service_name} --url`
-
-        ip_and_port = url.match /(?<ip>[0-9]+(?:\.[0-9]+){3}):(?<port>[0-9]+)/
-
-        case service_name
-        when "mysql-service"
-          environment_variables.store("DB_HOST", ip_and_port[:ip])
-          environment_variables.store("DB_PORT", ip_and_port[:port])
-        when "redis-service"
-          environment_variables.store("REDIS_HOST", ip_and_port[:ip])
-          environment_variables.store("REDIS_PORT", ip_and_port[:port])
-        end
-      }
-
-      return environment_variables
-    end
-
-    def self.minikube_status
-      output = `#{SctCore::Helper.minikube} status`
-
-      if output.scan(/Running/).length != 3 && output.scan(/Configured/).length != 1
-        UI.important("Please check your minikube status. If all services are stopped you should start the minikube first.")
-        exit
-      end
-    end
-  end
-end

data/shell/lib/shell/docker/yarn.rb

@@ -1,17 +0,0 @@
-require "sct_core"
-require_relative "docker"
-
-module Shell
-    class Yarn < Docker
-
-        # Configure the Yarn command
-       def self.config
-            self.set_image("eu.gcr.io/dev-pasc-vcdm/helpers-yarn:latest", true)
-            self.set_pwd_as_volume("/app")
-            self.add_volume(SctCore::Helper.convertWSLToWindowsPath("#{SctCore::Helper.windowsHomePath || SctCore::Helper.homePath}/.cache") , "/.cache")
-            self.map_port(8081, 8080)
-            self.map_port(9001)
-            self.set_current_user_and_group()
-        end
-    end
-end

data/shell/lib/shell/tools.rb

@@ -1,7 +0,0 @@
-module Shell
-    TOOLS = [
-      :yarn,
-      :composer,
-      :php
-    ]
-end