sct 0.1.17 → 0.1.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb3124f71d7225fc1c88fb1385b1de8c308b3cb9dcd3621c57d82c681b90ea10
-  data.tar.gz: bdc089394ec064af60751b213a57f491752bb3184e6eacdc11d8367ed65d7658
+  metadata.gz: 61cca19491733244389c6a46e8c8fd8fd226b3cdab4fb8537b17a4e6d51d196e
+  data.tar.gz: 3057200714457d8b312f34f542454019155e634137d8a0de5ffe4fee93538d90
 SHA512:
-  metadata.gz: a8a45d11bc4c50a627a913a8a38cd602eadd4520c2064a14801b9c31bc5e3943f6cb0c2cf2487bc8e191096b81a9797f12790a73267e46758fb6403ea5c1cec3
-  data.tar.gz: 696c6ae0977971f48f9460113b11aca055a6687f884adb70606eab9d2d6822bfb37c33c8cc45bd66e8bc216b601b750fa24d45babef9a0e0c638bd32f8e17f31
+  metadata.gz: 721bcf403b7292dad0bec08f9d0198ad64acc9ab5ffa0200299499d51b7fb3b15fb859f5812c03347484fe5175263d73af86072f65138bb3cdda39e3ba532621
+  data.tar.gz: 19386f51a743615e480a579ce3fbb7eb17859a0f8bd2e57c21b9ce57562ac6c6436bcee1d6b845004317d160e2b2d288703a07c5829dfd02374b286cbe8a9a4c

data/bin/sct

@@ -1,8 +1,5 @@
 #!/usr/bin/env ruby
 
-require 'commander/import'
-require 'sct'
-
 if RUBY_VERSION < '2.0.0'
   abort("sct requires Ruby 2.0.0 or higher")
 end
@@ -11,6 +8,8 @@ def self.windows?
   (/cygwin|mswin|mingw|bccwin|wince|emx/ =~ RUBY_PLATFORM) != nil
 end
 
+require 'sct/cli_tools_distributor'
+
 if ARGV.include?('-v') || ARGV.include?('--version')
     # This will print out the sct binary path right above the
     # version number. Very often, users are not aware they have
@@ -20,4 +19,4 @@ if ARGV.include?('-v') || ARGV.include?('--version')
     puts("-----------------------------")
 end
 
-Sct::SctCore.take_off(Sct.constants.map(&Sct.method(:const_get)).grep(Class))
+Sct::CLIToolsDistributor.take_off

data/cluster/lib/cluster.rb

@@ -0,0 +1,6 @@
+require 'sct_core'
+
+require 'terminal-table'
+
+require_relative 'cluster/runner'
+require_relative 'cluster/module'

data/cluster/lib/cluster/commands_generator.rb

@@ -0,0 +1,109 @@
+require 'commander'
+require_relative 'runner'
+
+module Cluster
+    class CommandsGenerator
+        include Commander::Methods
+
+        def self.start
+            self.new.run
+        end
+
+        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|
+
+                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
+                end
+
+            end
+
+            command :down do |c|
+
+                c.syntax = 'sct cluster down'
+                c.description = 'stop the cluster'
+
+                c.action do |args, options|
+                    Cluster::Runner.new.down
+                end
+            end
+
+            command :reset do |c|
+
+                c.syntax = 'sct cluster reset'
+                c.description = 'reset your cluster and start with a clean cluster'
+
+                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|
+                    Cluster::Runner.new.status
+                end
+            end
+
+            command :'update config' do |c|
+
+                c.syntax = 'sct cluster update config'
+                c.description = 'update the cluster configuration'
+
+                c.action do |args, options|
+                    Cluster::Runner.new.update_config
+                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'
+
+                c.action do |args, options|
+
+                    Cluster::Runner.new.apply_pods
+
+                end
+            end
+
+            default_command :status
+
+            run!
+        end
+    end
+end

data/cluster/lib/cluster/module.rb

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

data/{lib/sct/commands/cluster.rb → cluster/lib/cluster/runner.rb}

@@ -1,59 +1,39 @@
-require 'sct/command_interface'
-require 'terminal-table'
-
-module Sct
-
-    class ClusterCommand
-
-        IS_PUBLIC_COMMAND = true
-        SYNTAX = 'sct cluster up | sct cluster down | sct cluster setup | sct cluster reset | sct cluster update-config | sct cluster delete-stalled-pods'
-        SUMMARY = 'Perform actions on the minikube cluster.'
-        EXAMPLE = 'sct cluster up | sct cluster down | sct cluster setup | sct cluster reset | sct cluster update-config | sct cluster delete-stalled-pods'
-        EXAMPLE_DESCRIPTION = 'Perform actions on the minikube cluster.'
-        DESCRIPTION = "sct cluster allows you to start, stop, setup/reset, update the config, or delete the stalled pods of the Spend Cloud minikube cluster."
-
-        OPTIONS = []
-
-        def execute(args, options)
-            return puts "SCT has not been initialized. Run 'sct init' first.".red unless Sct::Config.exists
-
-            case args[0]
-                when "up"
-                    up
-                when "down"
-                    down
-                when "update-config"
-                    update_config
-                when "setup", "reset"
-                    reset
-                when "delete-stalled-pods"
-                    delete_stalled_pods(feedback: true)
-                when "status"
-                    status
-                else
-                    puts "Unknown or missing argument. Please run 'sct cluster up', 'sct cluster down', 'sct cluster setup', 'sct cluster reset', 'sct cluster update-config', or 'sct cluster delete-stalled-pods'.".red
-            end
-        end
+module Cluster
+    class Runner
 
-        def up
-            start
+        def launch
+            return UI.error("SCT has not been initialized. Run 'sct init' first.") unless SctCore::Config.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"
             post_start
         end
 
+        def start_cluster
+            if SctCore::Helper.operatingSystem == SctCore::Helper::MAC_OS
+                run_command "#{minikube} start --cpus=$(sysctl -n hw.ncpu) --memory=8G"
+            else
+                run_command "#{minikube} start --cpus=$(cat /proc/cpuinfo | grep processor | wc -l) --memory=10G"
+            end
+            run_command "#{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"
+            UI.success("\n✔️ You can visit your environment at 👉 https://spend-cloud.spend.cloud.local 👌")
+        end
+
         def down
             run_command "#{minikube} stop"
         end
 
         def reset
             run_command "#{minikube} delete"
-            start
+            start_cluster
             create_secrets
-            run_command "#{minikube} addons enable registry-creds"
-            run_command "#{minikube} addons enable ingress"
-            run_command "kubectl rollout status -n kube-system deployment/registry-creds"
-            run_command "kubectl rollout status -n kube-system deployment/nginx-ingress-controller"
+            enable_addons
             wait_for_gcr_secret
             run_command "kubectl apply -f ~/development/spend-cloud/k8s/ingress.yml"
             wait_for_ingress_ip
@@ -63,51 +43,122 @@ module Sct
             post_start
         end
 
+        def enable_addons
+            enable_addon "registry-creds"
+            enable_addon "ingress"
+        end
+
+        def enable_addon(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]}"
+        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] }
+
+            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
+
+        def delete_all_pods
+            run_command "kubectl delete pods --all"
+        end
+
+        def delete_pods(args)
+            run_command "kubectl delete pods #{args.join(" ")}"
+        end
+
+        def apply_pods
+            run_command "kubectl apply -f ~/development/spend-cloud/k8s/"
+        end
+
         def update_config
-            if Sct::Helpers.operatingSystem == Sct::Helpers::WINDOWS
-                windows_home_path = Sct::Helpers.windowsHomePath
+            if SctCore::Helper.operatingSystem == SctCore::Helper::WINDOWS
+                windows_home_path = SctCore::Helper.windowsHomePath
                 kube_file_path = windows_home_path+"/.kube/config"
 
                 if !File.exists?(kube_file_path)
-                    return puts "#{kube_file_path} doesn't exist".red
+                    return UI.error("#{kube_file_path} doesn't exist")
                 end
 
                 run_command "sed -e 's~\\\\~/~g' -e 's~C:~/mnt/c~g' < #{kube_file_path} > ~/.kube/minikube-config"
 
-                puts "#{kube_file_path} copied to ~/.kube/minikube-config".green
+                UI.success("#{kube_file_path} copied to ~/.kube/minikube-config")
             end
 
             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 delete pod -n kube-system #{pods("kube-system").map { |pod| pod[:name] if pod[:name].start_with? "coredns" } .compact.join(" ")}"
+            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"
         end
 
-        def delete_stalled_pods(feedback: false)
-            stalled_pods = pods.select { |pod| pod[:stalled] }
+        def deployments(namespace = "default")
+            output = `kubectl get deployments -n #{namespace}`
 
-            if stalled_pods.empty?
-                puts "There are no stalled pods.".green if feedback
-            else
-                run_command "kubectl delete pods #{stalled_pods.map { |pod| pod[:name] } .join(" ")}"
-            end
-        end
+            # split output lines
+            lines = output.split "\n"
 
-        def start
-            if Sct::Helpers.operatingSystem == Sct::Helpers::MAC_OS
-                run_command "#{minikube} start --cpus=$(sysctl -n hw.ncpu) --memory=8G"
-            else
-                run_command "#{minikube} start --cpus=$(cat /proc/cpuinfo | grep processor | wc -l) --memory=10G"
+            #  exclude first line (table header)
+            lines = lines[1..-1]
+
+            # get name and status of each pod
+            lines.map do |line|
+                columns = line.split(" ")
+
+                name = columns[0]
+
+                {
+                    name: name
+                }
             end
-            run_command "#{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"
-            puts "\n✔️ You can visit your environment at 👉 https://spend-cloud.spend.cloud.local 👌"
+        def pods(namespace = "default")
+            output = `kubectl get pods -n #{namespace}`
+
+            # split output lines
+            lines = output.split "\n"
+
+            #  exclude first line (table header)
+            lines = lines[1..-1]
+
+            # get name and status of each pod
+            lines.map do |line|
+                columns = line.split(" ")
+
+                name = columns[0]
+                status = columns[2]
+                stalled = status == "ErrImagePull" || status == "ImagePullBackOff"
+
+                {
+                    name: name,
+                    status: status,
+                    stalled: stalled
+                }
+            end
         end
 
         def create_secrets
@@ -123,119 +174,87 @@ module Sct
         end
 
         def wait_for_gcr_secret
-            puts "Waiting for Google Cloud Registry secret to become available...".yellow
+            UI.important("Waiting for Google Cloud Registry secret to become available...")
 
             while ! `kubectl get secrets`.include? "gcr-secret"
                 sleep 5
             end
 
-            puts "Google Cloud Registry secret is now available.".green
+            UI.success("Google Cloud Registry secret is now available.")
         end
 
         def wait_for_ingress_ip
-            puts "Waiting for ingress IP to become available...".yellow
+            UI.important("Waiting for ingress IP to become available...")
 
             while `kubectl describe ingress | grep "Address" | awk '{print $2}'`.empty?
                 sleep 5
             end
 
-            puts "Ingress IP is now available.".green
-        end
-
-        def wait_for_pods
-            puts "Waiting for pods to become ready...".yellow
-
-            while ! pods.all? { |pod| pod[:status] == "Running" }
-                delete_stalled_pods
-
-                sleep 5
-            end
-
-            puts "Pods are now ready.".green
+            UI.success("Ingress IP is now available.")
         end
 
         def status
-            minikube_status
-            pods_status
-            system_pods
-            current_contexts
-        end
+            print_contexts
+            print_minikube_status
 
-        def pods_status
-          rows = []
-          pods.map do |pod|
-            status = pod[:status] == "Running" ? pod[:status].green : pod[:status].red
-            rows << [pod[:name], status]
-          end
-          puts Terminal::Table.new :title => "Pods Status".green, :headings => ['Name', 'Status'], :rows => rows
-        end
-
-        def system_pods
-          rows = []
-          pods("kube-system").map do |pod|
-            status = pod[:status] == "Running" ? pod[:status].green : pod[:status].red
-            rows << [pod[:name], status]
-          end
-          puts Terminal::Table.new :title => "System pods Status".green, :headings => ['Name', 'Status'], :rows => rows
+            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 current_contexts
+        def print_contexts
           output = `kubectl config get-contexts`
 
           lines = output.split "\n"
           lines = lines[1..-1]
 
-          rows = []
-          lines.map do |line|
-              columns = line.split(" ")
+          rows = lines.map do |line|
+            columns = line.split(" ")
 
-              current_context = columns[0] == "*" ? "Yes".green : "No".red
-              rows << [columns[2], current_context]
+            current_context = columns[0] == "*" ? "Yes".green : "No".red
+
+            [columns[2], current_context]
           end
-          puts Terminal::Table.new :title => "Contexts".green, :headings => ['Cluster', 'Using context'], :rows => rows
+
+          puts Terminal::Table.new title: "Contexts".green, headings: ['Cluster', 'Using context'], rows: rows
         end
 
-        def minikube_status
+        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 = `#{minikube} status`
 
           lines = output.split "\n"
 
-          rows = []
-          lines.map do |line|
+          rows = lines.map do |line|
               columns = line.split(" ")
 
-              rows << [columns[0], columns[1]]
+              [columns[0][0..-2], columns[1]]
           end
-          puts Terminal::Table.new :title => "Minikube Status".green, :headings => ['Name', 'Status'], :rows => rows
         end
 
-        def pods(namespace = nil)
-            if namespace
-                output = `kubectl get pods -n #{namespace}`
-            else
-                output = `kubectl get pods`
-            end
+        def print_pods_status(namespace = "default")
 
-            # split output lines
-            lines = output.split "\n"
-
-            #  exclude first line (table header)
-            lines = lines[1..-1]
+          pods_list = pods(namespace)
 
-            # get name and status of each pod
-            lines.map do |line|
-                columns = line.split(" ")
+          if pods_list.to_a.empty?
+            return
+          end
 
-                name = columns[0]
-                status = columns[2]
-                stalled = status == "ErrImagePull" || status == "ImagePullBackOff"
+          rows = pods_list.map do |pod|
+            [
+                pod[:name],
+                pod[:status] == "Running" ? pod[:status].green : pod[:status].red
+            ]
+          end
 
-                {
-                    name: name,
-                    status: status,
-                    stalled: stalled
-                }
-            end
+          puts Terminal::Table.new title: "Pods (namespace: #{namespace})".green, headings: ['Name', 'Status'], rows: rows
         end
 
         def run_command command
@@ -245,15 +264,11 @@ module Sct
         end
 
         def minikube
-            if Sct::Helpers.operatingSystem == Sct::Helpers::WINDOWS
+            if SctCore::Helper.operatingSystem == SctCore::Helper::WINDOWS
                 return "minikube.exe"
             else
                 return "minikube"
             end
         end
-
-        implements CommandInterface
-
     end
-
 end