sct 0.1.35 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 730e908365c08b32f6c0bcffce79d1497b2139190f68980cb2c3d340a233dee8
-  data.tar.gz: 813a1f8db688ecd7ad902bf87d2415c4000933c2aac86957d08b43fe0513a8e5
+  metadata.gz: 14d8446d9ad177cfe1423a229687670d9731830389539014fda62491d09ca054
+  data.tar.gz: fa3083af252bb67c0b776d270a69b29605e6ce33e06cfe8b6625998ab0cff29a
 SHA512:
-  metadata.gz: 2e813fe74dd20bc360a2644cf57bf4731b122b0916e4ccfb64259fad0e69d9f5238741b9eafcd6fa0b1a523dbd5f617b83d55dee709a61ce290fdf07e47b8031
-  data.tar.gz: ab9e05165e62681cb5a851eac335320ef44030351482ab7307a36fad1b900f6fe8036a10b72d593d88c6d6edd3e2fc3b3b7c5a7fda5daae5484e77606ecab0f9
+  metadata.gz: d62a9c18d78ce4a821d32cb0848c4bbc2dc88e1ca526f7600c1bb8b7945a36522f157e94a365036cc68e7549ae76f90368d2c54a1335b43d2cc2233c4c354d54
+  data.tar.gz: 98381741d7493183b420c176843062d005b8f6620d0a67ce0739d53da77ae2bf11c73c60817b2a0965dfd41a338a249446ec482ee27ba465f8b92708cb768db8

data/cluster/lib/cluster/commands_generator.rb

@@ -2,96 +2,92 @@ require 'commander'
 require_relative 'runner'
 
 module Cluster
-    class CommandsGenerator
-        include Commander::Methods
+  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 :start do |c|
-                c.syntax = "sct cluster start"
-                c.description = "start the cluster"
-
-                c.action do |args, options|
-                    Cluster::Runner.new.start
-                end
-
-            end
-
-            command :stop do |c|
-                c.syntax = 'sct cluster stop'
-                c.description = 'stop the cluster'
-
-                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"
+    def self.start
+      self.new.run
+    end
 
-                c.action do |args, options|
-                    Cluster::Runner.new.restart
-                end
+    def run
+      program :name, 'cluster'
+      program :version, Sct::VERSION
+      program :description, 'CLI for \'cluster\' - Manage your local Docker cluster'
 
-            end
+      global_option('--verbose') { $verbose = true }
 
-            command :delete do |c|
-                c.syntax = "sct cluster delete"
-                c.description = "delete the cluster"
+      command :start do |c|
+        c.syntax = "sct cluster start"
+        c.description = "start the cluster"
+        c.option '--build', '(re)build images before starting'
+        c.option '--pull', 'pull latest images before starting'
 
-                c.action do |args, options|
-                    Cluster::Runner.new.delete
-                end
+        c.action do |args, options|
+          Cluster::Runner.new.start args, options
+        end
+      end
 
-            end
+      command :stop do |c|
+        c.syntax = 'sct cluster stop'
+        c.description = 'stop the cluster'
 
-            command :reset do |c|
-                c.syntax = 'sct cluster reset'
-                c.description = 'delete the cluster and start a new cluster'
+        c.action do |args, options|
+          Cluster::Runner.new.stop
+        end
+      end
 
-                c.action do |args, options|
-                    Cluster::Runner.new.reset
-                end
-            end
+      command :restart do |c|
+        c.syntax = "sct cluster restart"
+        c.description = "restart the cluster"
 
-            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.restart
+        end
+      end
 
-                c.action do |args, options|
-                    Cluster::Runner.new.status
-                end
-            end
+      command :delete do |c|
+        c.syntax = "sct cluster delete"
+        c.description = "delete the cluster"
 
-            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.delete
+        end
+      end
 
-                c.action do |args, options|
-                    Cluster::Runner.new.update_config
-                end
-            end
+      command :reset do |c|
+        c.syntax = 'sct cluster reset'
+        c.description = 'delete the cluster and start a new cluster'
 
-            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.reset args, options
+        end
+      end
 
-                c.action do |args, options|
-                    Cluster::Runner.new.apply_deployments
-                end
-            end
+      command :status do |c|
+        c.syntax = 'sct cluster status'
+        c.description = 'see the status of your cluster'
 
-            run!
+        c.action do |args, options|
+          Cluster::Runner.new.status
+        end
+      end
+
+      command :logs do |c|
+        c.syntax = 'sct cluster logs'
+        c.description = 'see the logs of your cluster'
+        c.option '-f', 'follow log output'
+        c.option '--follow', 'follow log output'
+        c.option '-t', 'show timestamps'
+        c.option '--timestamps', 'show timestamps'
+        c.option '--tail LINES', 'number of lines to show from the end of the logs for each container (default: "all")'
+
+        c.action do |args, options|
+          Cluster::Runner.new.logs args, options
         end
+      end
+
+      run!
     end
+
+  end
 end

data/cluster/lib/cluster/runner.rb

@@ -1,343 +1,70 @@
 module Cluster
-    class Runner
+  class Runner
 
-        def start
-            SctCore::Helper.ensure_windows_administrator # "sct hostfile" will need it later on
-
-            existing_cluster = cluster_exists?
-
-            start_cluster
-
-            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
-                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
-
-            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"
+    def run command, options = {}
+      begin
+        if !system command, options
+          raise command.red
         end
+      rescue Interrupt
+        # user pressed Ctrl+C, do nothing
+      end
+    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 "minikube start --driver=hyperkit --vm=true --cpus=$(sysctl -n hw.ncpu) --memory=8G"
-            else
-                run_command "minikube start --driver=docker --cpus=$(cat /proc/cpuinfo | grep processor | wc -l) --memory=3G"
-            end
-            update_config
-        end
-
-        def post_start
-            wait_for_pods
-            copy_proactive_accounts_file
-            if SctCore::Helper.operatingSystem == SctCore::Helper::UBUNTU
-                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 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...")
-
-            previous_lines = 0
-
-            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
-
-                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
-
-                sleep 5
-            end
-
-            previous_lines.times do
-                print "\033[1A\033[K" # move the cursor up a line and clear the line
-            end
-
-            UI.success("Pods are now ready.")
-        end
-
-        def deployments(namespace = "default")
-            output = `kubectl get deployments -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]
-
-                {
-                    name: name
-                }
-            end
-        end
-
-        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]
-                ready = columns[1].split("/").reduce { |l, r| l == r }
-                replicas = columns[1]
-                status = columns[2]
-
-                {
-                    name: name,
-                    ready: ready,
-                    replicas: replicas,
-                    status: status
-                }
-            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 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(" ")
+    def run_dc command, options = {}
+      run "docker-compose -f ~/development/spend-cloud/docker-compose.yml #{command}", options
+    end
 
-              [columns[0][0..-2], columns[1]]
-          end
-        end
+    def start args, options
+      if options.pull
+        run_dc "pull"
+      end
 
-        def print_pods_status(namespace = "default")
-            output = get_pods_status(namespace)
+      if options.build
+        run_dc "build #{options.pull ? "--pull" : ""}"
+      end
 
-            puts output if output
-        end
+      run "docker container prune -f"
 
-        def get_pods_status(namespace = "default")
-          rows = pods(namespace).map do |pod|
-            status = pod[:status]
-            replicas = pod[:replicas]
+      run_dc "up --detach"
 
-            [
-                pod[:name],
-                status == "Running" ? status.green : status.red,
-                pod[:ready] ? replicas.green : replicas.red
-            ]
-          end
+      if options.pull or options.build
+        system "docker image prune -f"
+      end
 
-          if rows.empty?
-            return
-          end
-
-          return Terminal::Table.new title: "Pods (namespace: #{namespace})".green, headings: ['Name', 'Status', 'Replicas ready'], rows: rows
-        end
+      UI.success("\n✔️ You can visit your environment at 👉 https://spend-cloud.dev.spend.cloud 👌")
+    end
 
-        def copy_proactive_accounts_file
-            container_name = "proactive-config"
-            pod_id = pods().select {|pod| pod[:name].start_with?(container_name)}.first[:name]
+    def stop
+      run_dc "down --remove-orphans"
+    end
 
-            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
+    def restart
+      run_dc "restart"
+    end
 
-            UI.success("ProActive accounts file is available")
-        end
+    def delete
+      run_dc "down --remove-orphans -v"
+    end
 
-        def create_keycloak_database_user
-            container_name = "mysql-service"
-            pod_id = pods().select {|pod| pod[:name].start_with?(container_name)}.first[:name]
+    def reset args, options
+      delete
+      start args, options
+    end
 
-            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"
+    def status
+      run_dc "ps"
+    end
 
-            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"
+    def logs args, options
+      command = "logs"
 
-            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
+      command << " --follow" if options.f or options.follow
+      command << " --timestamps" if options.t or options.timestamps
+      command << " --tail #{options.tail}" if options.tail
 
-        def run_command command, options = {}
-            if ! system command, options
-                raise command.red
-            end
-        end
+      run_dc "#{command} #{args.join " "}"
     end
+
+  end
 end