sct 0.1.28 → 0.1.34

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2795077123ba193f891933659f88c61cb4a986ebc4a5c7bf8ced2fd9b9b54a97
-  data.tar.gz: 8478af6c3a869f524b09bc607ae09acbc48eed401777366947fc270a39166a2b
+  metadata.gz: a44226fb281fd62b413a72c92fc8f747a02be4da29e4e76a5c2f431e9dfa27b7
+  data.tar.gz: 8ac335f5d43ba44212e9131b93296d3796e678442aac3e6f9039d23a497fa763
 SHA512:
-  metadata.gz: deecf2931622dda191ee00ffc6412a41c7aa4ac8df88006f8eeab183c8d50c543fb2d25f5012c47157f0faa1208431d450716e9b6f50506991aaa1a5f3e95dbc
-  data.tar.gz: afcf8914cbd3efba0e46764b5ed8633f570ec2e9b272a70a28cf48d11fd29bd41beaa1b9cd4896a263f99d657835fccb5329a245a160a009a47f17a4915589cb
+  metadata.gz: 58789cf672976004e0853f46924c62642266d312b3f5f160a30c10a9cf9edc9ad36c25ffea311c4b9a79fd29ea205cc5c8e552941fe673ef2072c96cbf3b8dbf
+  data.tar.gz: 51caa6da2bc2e458cdae40347f84f6d830896879c629d3d3d642b44e2781d7a7bd082321dcd1342954ebc1371021ba2f855eaf29aefd2dcf4621eca2613e478f

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,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