sct 0.1.27 → 0.1.33

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ff08000486ce837ef860abef5066f502d812fa618aee9cdc4ff1675de5e1db99
-  data.tar.gz: 82bb9f318eb66683a659df692022039b2c9e27896190f4d40273fb27d375b095
+  metadata.gz: b2e41b42a8946aed6b8dbe5433b5c3ee3c81bff9d067468bbb1918a6e2c68923
+  data.tar.gz: 5ccbfd3297e07405b088c5ee403ee03bad743e8fa35503c3edf4d609e31ca9a5
 SHA512:
-  metadata.gz: 4ec72ba0beb92e34c15e78a8d8ea8f25dc896ea783acf7404860bea66434c6c875ca41636e76f096024497badecadbb53917d5941eced8687e0df4076e00bb29
-  data.tar.gz: 13360a17d8c27c6cd6707585a35fd0c13503296be34b2f8a9fe918f9470e6f40c68a5d4c3c7af319d00e7de66c12553b67710d7a3da1a65dcd3ce173dba3bfac
+  metadata.gz: 526a75d3b045b8f627a41fe54f7ddae8bf953c132e609371469059955769c7f13b4e87d0dbf8e0c8d3994d5cbf4bcbbb8d01ed3d4fb604f12deea3eccc80eebf
+  data.tar.gz: 89e5331e801bdacb9b8ce26ff4077bee6c9a86c51793cc7152680e4f684e455785e0186fb1045306316dac3eb6455580d1cf1c646db816e64b690dd26715f3da

data/cluster/lib/cluster/commands_generator.rb

@@ -9,63 +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 :reset do |c| 
+            command :restart do |c|
+                c.syntax = "sct cluster restart"
+                c.description = "restart the cluster"
+
+                c.action do |args, options|
+                    Cluster::Runner.new.restart
+                end
+
+            end
+
+            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'
 
@@ -74,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,165 @@
 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"
-            post_start
-        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"
+            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
-                run_command "#{SctCore::Helper.minikube} start --cpus=$(cat /proc/cpuinfo | grep processor | wc -l) --memory=10G"
+                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
+                create_keycloak_database_user
+                run_command "kubectl apply -f ~/development/spend-cloud/k8s/keycloak-server.yml"
+                wait_for_pods
+                run_command "kubectl apply -f ~/development/spend-cloud/k8s/"
             end
-            run_command "#{SctCore::Helper.minikube} ssh -- 'sudo su -c \"echo 10048576 > /proc/sys/fs/inotify/max_user_watches\"'"
-            update_config
+
+            post_start
         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 👌")
+        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 down
-            run_command "#{SctCore::Helper.minikube} stop"
+        def delete
+            run_command "minikube delete"
         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
+            SctCore::Helper.ensure_windows_administrator # "sct hostfile" will need it later on
+
+            delete
+            start
         end
 
-        def enable_addons
-            enable_addon "registry-creds"
-            enable_addon "ingress"
+        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 enable_addon(addon)
-            run_command "#{SctCore::Helper.minikube} addons enable #{addon}"
+        def update_config
+            run_command "kubectl config use-context minikube"
 
-            deployment = deployments("kube-system").find { |deployment| deployment[:name].include? addon }
+            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
 
-            run_command "kubectl rollout status -n kube-system deployment/#{deployment[:name]}"
+        def apply_deployments
+            run_command "kubectl apply -f ~/development/spend-cloud/k8s/"
         end
 
-        def wait_for_pods
-            UI.important("Waiting for pods to become ready...")
 
-            while ! pods.all? { |pod| pod[:status] == "Running" }
-                delete_stalled_pods
+        def cluster_exists?
+            if system "minikube status", { out: "/dev/null" }
+                # cluster exists and is running
+                return true
+            end
 
-                sleep 5
+            if $?.exitstatus == 85
+                # cluster does not exist
+                return false
             end
 
-            UI.success("Pods are now ready.")
+            # cluster exists but is stopped
+            return true
         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
+        def start_cluster
+            if SctCore::Helper.operatingSystem == SctCore::Helper::MAC_OS
+                run_command "minikube start --driver=hyperkit --vm=true --cpus=$(sysctl -n hw.ncpu) --memory=8G"
             else
-                run_command "kubectl delete pods #{stalled_pods.map { |pod| pod[:name] } .join(" ")}"
+                run_command "minikube start --driver=docker --cpus=$(cat /proc/cpuinfo | grep processor | wc -l) --memory=3G"
             end
+            update_config
         end
 
-        def delete_all_pods
-            run_command "kubectl delete pods --all"
+        def post_start
+            wait_for_pods
+            copy_proactive_accounts_file
+            if SctCore::Helper.operatingSystem != SctCore::Helper::WINDOWS
+                UI.success("\nAdding SSH tunnel to port 443!")
+                run_command "sudo ssh -f -N -i $(minikube ssh-key) docker@$(minikube ip) -L 443:127.0.0.1:443"
+            end
+#             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.dev.spend.cloud 👌")
         end
 
-        def delete_pods(args)
-            run_command "kubectl delete pods #{args.join(" ")}"
+        def enable_addons
+            enable_addon "registry-creds"
+            enable_addon "ingress"
         end
 
-        def apply_pods
-            run_command "kubectl apply -f ~/development/spend-cloud/k8s/"
+        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 update_config
-            if SctCore::Helper.operatingSystem == SctCore::Helper::WINDOWS
-                windows_home_path = SctCore::Helper.windowsHomePath
-                kube_file_path = windows_home_path+"/.kube/config"
+        def wait_for_pods
+            UI.important("Waiting for pods to become ready...")
+
+            previous_lines = 0
 
-                if !File.exists?(kube_file_path)
-                    return UI.error("#{kube_file_path} doesn't exist")
+            while ! pods.all? { |pod| pod[:ready] }
+                pods_status_lines = get_pods_status.to_s.lines.map { |line| line.chomp }
+
+                current_lines = pods_status_lines.length
+
+                line_difference = current_lines - previous_lines
+
+                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
+
+                    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
 
-                run_command "sed -e 's~\\\\~/~g' -e 's~C:~/mnt/c~g' < #{kube_file_path} > ~/.kube/minikube-config"
+                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
+
+                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 +197,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 +242,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 +260,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 +276,66 @@ 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 copy_proactive_accounts_file
+            container_name = "proactive-config"
+            pod_id = pods().select {|pod| pod[:name].start_with?(container_name)}.first[:name]
+
+            begin
+                UI.important("Checking ProActive accounts file...")
+                run_command "kubectl exec #{pod_id} -- test -e /data/proactive_accounts.ini", [:out, :err] => File::NULL
+            rescue => e
+                UI.important("Copying ProActive accounts file to deployments...")
+                src_path = "#{Dir.home()}/development/spend-cloud/k8s/conf/proactive_accounts.ini"
+                command = "kubectl cp #{src_path} #{pod_id}:/data/proactive_accounts.ini -c #{container_name}"
+                run_command command
+            end
+
+            UI.success("ProActive accounts file is available")
+        end
+
+        def create_keycloak_database_user
+            container_name = "mysql-service"
+            pod_id = pods().select {|pod| pod[:name].start_with?(container_name)}.first[:name]
+
+            UI.important("Creating keycloak user")
+            create_user = "CREATE USER 'keycloak'@'%' IDENTIFIED BY 'keycloak';"
+            run_command "kubectl exec #{pod_id} -- mysql -e '#{create_user}' >> /dev/null"
+
+            UI.important("Creating keycloak database")
+            create_database = "CREATE DATABASE keycloak CHARACTER SET utf8 COLLATE UTF8_UNICODE_CI;"
+            run_command "kubectl exec #{pod_id} -- mysql -e '#{create_database}' >> /dev/null"
+
+            UI.important("Granting privileges to keycloak user")
+            grant_privileges = "GRANT ALL PRIVILEGES ON keycloak.* TO 'keycloak'@'%';"
+            run_command "kubectl exec #{pod_id} -- mysql -e '#{grant_privileges}' >> /dev/null"
         end
 
-        def run_command command
-            if ! system command
+        def run_command command, options = {}
+            if ! system command, options
                 raise command.red
             end
         end