sct 0.1.14 → 0.1.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2377fe5a5cfd760e9a8ed93321849ac8207588721325ce48aa2d6bd8cf8f631e
-  data.tar.gz: 5952de0af59fb21add421797a785584763a27286f94feb8303aadfaa3e57cc91
+  metadata.gz: e738ce105b1b145395e1126e272a2100112b7bc2282963b5ea08f76e0057f26e
+  data.tar.gz: 46076d0d575a48bca094be8a6eaf298ca3cb9943788ed8e52cbe131b1708764f
 SHA512:
-  metadata.gz: 85ce38ef50434f38d01560de81c688aeea4c5ae9362c9f7b6eab2ea77acb8381906a2adcc506d8f4e2f812ec4d191ae8fc6d80e6c49e1ebcf4ac9de0a711ccf2
-  data.tar.gz: 1678c667cf147b5c406819bfe5b2aa00624de2f08a42776d49725cc8416457e89bf3c96f06f8b25cdd02182e12aab191cb42ca83c166f8cdffb2b809d2d44e5e
+  metadata.gz: c56a04592b7e8e81065dbad8c2f0913df26e90381bf2d0581741ad4e34db4b044da88688b8a1a5fdf8e08a7ac89676867934efc9f8ff6641eda2437c62df3ef0
+  data.tar.gz: a598f85d2e88af7230783a9918a1d0d90c5e6dd622fd3b98fbed1ea52081d3acde39e95bbf03cc8811e6a0eb6c66c7d7c37e5ff98dad51eb3003bc2f0bb7ea3d

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,95 @@
+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
+                    UI.important("Currently its not possible to delete all pods") if options.all
+                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/cluster/lib/cluster/runner.rb

@@ -0,0 +1,239 @@
+module Cluster
+    class Runner
+        
+        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_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"
+            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 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 update_config
+            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 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"
+
+                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__)}"
+            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 pods(namespace = nil)
+            if namespace
+                output = `kubectl get pods -n #{namespace}`
+            else
+                output = `kubectl get pods`
+            end
+
+            # split output lines
+            lines = output.split "\n"
+
+            #  exclude first line (table header)
+            lines = lines[1..-1]
+
+            if lines.to_a.empty?
+                return 
+            end
+
+            # 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
+            run_command "kubectl create secret generic gcloud-credentials --from-file=\"$(echo ~)/.config/gcloud/application_default_credentials.json\""
+            run_command "kubectl create secret generic -n kube-system registry-creds-dpr --from-literal DOCKER_PRIVATE_REGISTRY_PASSWORD=changeme --from-literal DOCKER_PRIVATE_REGISTRY_SERVER=changeme --from-literal DOCKER_PRIVATE_REGISTRY_USER=changeme"
+            run_command "kubectl patch secret -n kube-system registry-creds-dpr -p='{\"metadata\": {\"labels\": { \"app\": \"registry-creds\", \"cloud\": \"dpr\", \"kubernetes.io/minikube-addons\": \"registry-creds\"}}}'"
+            run_command "kubectl create secret generic -n kube-system registry-creds-ecr --from-literal AWS_ACCESS_KEY_ID=changeme --from-literal AWS_SECRET_ACCESS_KEY=changeme --from-literal AWS_SESSION_TOKEN=\"\" --from-literal aws-account=changeme --from-literal aws-assume-role=changeme --from-literal aws-region=changeme"
+            run_command "kubectl patch secret -n kube-system registry-creds-ecr -p='{\"metadata\": {\"labels\": { \"app\": \"registry-creds\", \"cloud\": \"ecr\", \"kubernetes.io/minikube-addons\": \"registry-creds\"}}}'"
+            run_command "kubectl create secret generic -n kube-system registry-creds-gcr --from-file=\"$(echo ~)/.config/gcloud/application_default_credentials.json\" --from-literal=gcrurl=\"https://eu.gcr.io\""
+            run_command "kubectl patch secret -n kube-system registry-creds-gcr -p='{\"metadata\": {\"labels\": { \"app\": \"registry-creds\", \"cloud\": \"gcr\", \"kubernetes.io/minikube-addons\": \"registry-creds\"}}}'"
+            run_command "kubectl create secret generic -n kube-system registry-creds-acr --from-literal ACR_PASSWORD=changeme --from-literal ACR_CLIENT_ID=changeme --from-literal ACR_URL=changeme"
+            run_command "kubectl patch secret -n kube-system registry-creds-acr -p='{\"metadata\": {\"labels\": { \"app\": \"registry-creds\", \"cloud\": \"acr\", \"kubernetes.io/minikube-addons\": \"registry-creds\"}}}'"
+        end
+
+        def wait_for_gcr_secret
+            UI.important("Waiting for Google Cloud Registry secret to become available...")
+
+            while ! `kubectl get secrets`.include? "gcr-secret"
+                sleep 5
+            end
+
+            UI.success("Google Cloud Registry secret is now available.")
+        end
+
+        def wait_for_ingress_ip
+            UI.important("Waiting for ingress IP to become available...")
+
+            while `kubectl describe ingress | grep "Address" | awk '{print $2}'`.empty?
+                sleep 5
+            end
+
+            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`
+
+          lines = output.split "\n"
+          lines = lines[1..-1]
+
+          rows = lines.map do |line|
+            columns = line.split(" ")
+
+            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
+        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 = `#{minikube} status`
+
+          lines = output.split "\n"
+
+          rows = lines.map do |line|
+              columns = line.split(" ")
+
+              [columns[0][0..-2], columns[1]]
+          end
+        end
+
+        def print_pods_status(namespace = nil)
+
+          pods_list = pods(namespace)
+
+          if pods_list.to_a.empty?
+            return 
+          end
+
+          rows = pods_list.map do |pod|
+            [
+                pod[:name],
+                pod[:status] == "Running" ? pod[:status].green : pod[:status].red
+            ]
+          end
+
+          puts Terminal::Table.new title: "Pods (namespace: #{namespace || "default"})".green, headings: ['Name', 'Status'], rows: rows
+        end
+
+        def run_command command
+            if ! system command
+                raise command.red
+            end
+        end
+
+        def minikube
+            if SctCore::Helper.operatingSystem == SctCore::Helper::WINDOWS
+                return "minikube.exe"
+            else
+                return "minikube"
+            end
+        end
+    end
+end

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,46 @@
+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
+            end
+        end
+    end
+end