kubert 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e5c74268cc6b8183802832e52b2915204446ecc3
-  data.tar.gz: 1be4118c38ac3bc70e1ccaae091a98224c53a4c2
+  metadata.gz: 11a4977bc3bcc125b5c7d631fde64ad7d4bcd857
+  data.tar.gz: 257585ae70feb31f2896193dab4ac09041100a95
 SHA512:
-  metadata.gz: 97697fadf8dcfe45a70457e8ad9c05dcd739e098ebeb9adb4d186449c62d62792bcb8ca168cd2e7705bc1478f1d34f4442f735432841e121e3e45435043e3767
-  data.tar.gz: 45ac797aad87616892d75ef0fd127d73f0b1181bafc324cb83d118e08d06dd876984dd140dd62483f10612da859dc5563663d40dec35a4b23d5d7d9cbfa7be30
+  metadata.gz: 0401b4d08e0b7cfb568368a8779c810e20fe466163a394a485afed04327b5855eed089769e997ae5573facce97531ac9bd4dec474b69f6d5c083a9d8e376a9db
+  data.tar.gz: 7f9705992329e778645ea4b0df82db81389b321bf7d3b81a018c81b786b44ea398ae904f84431fbab8f6e7bbfbe19d518013237462f3daab88e40fa6289e42cc

data/README.md

@@ -6,20 +6,23 @@
 
 Kubert assumes your kubernetes config file lives in `~/.kube/config` and reads that to talk to the cluster.
 
-If you don't intend to use KY for generating your deployment yml, you can ignore kubert's compile and rollback methods, which rely on ky and a Procfile to define the scope of a deployment as a group of related, seperate kubernetes deployments.  Typing `ky example` at the console will import example ky configuration, including kubert configuration.  You may ignore most of this if not using ky itself, and focus primarily on the kubert section of the yml for a few pieces of kubert configuration...  the important ones are these:
+Compile and Rollback actions are only available if using ky for generating your deployment yml.  Kubert checks the ky config for several values (procfile_path, deployment and image at present) to determine if ky is active and only defines compile/rollback commands if they are all configured.
+
+ky manages the scope of a deployment as a group of related, seperate kubernetes deployments.  Typing `ky example` at the console will import example ky configuration, including kubert configuration.  You may ignore/delete most of this if not using ky itself, and focus primarily on the kubert section of the yml for a few pieces of kubert configuration...  the important ones are these:
 
 ```
 project_name: "my-project"
 kubert:
   contexts:
-    staging: staging.example.com
+    staging: staging.example.com   # as many values here as you have distinct clusters in kubeconfig
     prod: production.example.com
-  excluded_deployments: [sanitize, migration]
+  excluded_deployments: [sanitize, migration] # optional/possibly uncommon use case, see below
   default_environment: stg
-  default_namespace: default
+  default_namespace: default       # defaults to same as default_environment, specify if different
   task_pod: console
-  console_command: rails c
-  command_prefix: bundle exec
+  console_command: rails c         # optional, but no console command unless present
+  command_prefix: bundle exec      # optional
+  kube_config_path: ~/.kube/config # No need to specify unless you store file elsewhere
 ```
 
 The project name is used by ky and assumes a metadata namespace for your app deployments in the format of `{{project_name}}-{{deployment_name}}`, so as long as your deployments obey this pattern it should be usable for you without ky.
@@ -33,6 +36,8 @@ Task pod is what is used for running consoles and executing tasks.  If not defin
 
 console_command and console_prefix are for opening a REPL and for prefixing all task commands with a common prefix
 
+kube_config_path is probably not needed unless your kubernetes config is located elsewhere
+
 ###Example usage
 ```
 $ kubert console                  # open a console on a task_pod
@@ -43,6 +48,7 @@ $ kubert context                  # print current kubectl context/cluster
 $ kubert deploy -e prd            # perform a production deployment
 $ kubert rollback -e prd          # rollback a production deployment
 $ kubert deploy                   # perform a deployment to the default environment
+$ kubert logs web                 # tail the logs from all web pods and interleave together
 ```
 
 A valid url may also be used in place of a file path for input.

data/lib/kubert.rb

@@ -6,50 +6,61 @@ require_relative "kubert/pods"
 require_relative "kubert/deployment"
 
 module Kubert
-  def self.kube_config
-    @kube_config ||= Kubeclient::Config.read(File.expand_path('~/.kube/config'))
+  extend self
+  DEFAULT_KUBE_CONFIG_PATH = '~/.kube/config'
+  def kube_config
+    @kube_config ||= Kubeclient::Config.read(File.expand_path(kube_config_path))
   end
 
-  def self.contexts
+  def kube_config_path
+    configuration[:kube_config_path] || DEFAULT_KUBE_CONFIG_PATH
+  end
+
+  def contexts
     configuration[:contexts] || []
   end
 
-  def self.task_pod
+  def task_pod
     configuration[:task_pod] || random_pod_type
   end
 
-  def self.default_environment
+  def default_environment
     configuration[:default_environment]
   end
 
-  def self.default_namespace
+  def default_namespace
     configuration[:default_namespace] || configuration[:default_environment]
   end
 
-  def self.context
+  def context
     kube_config.contexts.select {|c| kube_config.context.api_endpoint.match(c) }
   end
 
-  def self.console_command
+  def console_command
     Array(configuration[:console_command] && configuration[:console_command].split(" "))
   end
 
-  def self.command_prefix
+  def command_prefix
     configuration[:command_prefix]
   end
 
-  def self.excluded_deployments
+  def excluded_deployments
     configuration[:excluded_deployments] || []
   end
 
-  def self.configuration
-    @config ||= begin
-      config = KY::Configuration.new
-      (config[:kubert] || {}).merge(project_name: config[:project_name])
-    end
+  def ky_configuration
+    @ky_configuration ||= KY::Configuration.new
+  end
+
+  def ky_active?
+    ky_configuration[:image] && ky_configuration[:deployment] && ky_configuration[:procfile_path]
+  end
+
+  def configuration
+    @config ||= (ky_configuration[:kubert] || {}).merge(project_name: ky_configuration[:project_name])
   end
 
-  def self.client
+  def client
     @client ||= begin
       Kubeclient::Client.new(
         kube_config.context.api_endpoint,
@@ -64,7 +75,7 @@ module Kubert
 
   private
 
-  def self.random_pod_type
+  def random_pod_type
     Kubert.client.get_pods(namespace: current_namespace)
     .sample
     .metadata
@@ -73,8 +84,8 @@ module Kubert
     .first
   end
 
-  def self.current_namespace
-    KY::Configuration.new[:namespace]   ||
+  def current_namespace
+    ky_configuration[:namespace]        ||
     default_namespace                   ||
     (raise "MUST DEFINE A NAMESPACE FOR POD OPERATIONS, ky namespace, default_namespace or default_environment")
   end

data/lib/kubert/cli.rb

@@ -3,6 +3,12 @@ require 'thor'
 module Kubert
   class Cli < Thor
 
+    `hash kubectl 2>/dev/null;`
+    unless $?.success?
+      puts "Please install kubectl prior to kubert usage"
+      exit $?.to_i
+    end
+
     desc "list pod_type", "Display a list of one type of Pod, only Running by default"
     def list(pod_type, status=:running)
       puts Pods.list(pod_type, status)
@@ -20,9 +26,11 @@ module Kubert
       end
     end
 
-    desc "console", "Connect to a console on a task pod"
-    def console
-      execute(*Kubert.console_command)
+    if Kubert.console_command.any?
+      desc "console", "Connect to a console on a task pod"
+      def console
+        execute(*Kubert.console_command)
+      end
     end
 
     desc "execute command", "Connect to a task pod and run the specified command (with #{Kubert.command_prefix} prefix)"
@@ -35,26 +43,29 @@ module Kubert
       Pods.logs(pod_type, status)
     end
 
-    desc "deploy", "Perform a deployment"
-    method_option :namespace, type: :string, aliases: "-n"
-    method_option :environment, type: :string, aliases: "-e"
-    method_option :image_tag, type: :string, aliases: "-t"
-    method_option :configmap_path, type: :string, aliases: "-c"
-    method_option :secrets_path, type: :string, aliases: "-s"
-    method_option :output_dir, type: :string, aliases: "-o"
-    def deploy
-      Deployment.perform(options)
-    end
 
-    desc "rollback", "Rollback a deployment, reverse of a kubert deploy command with same flags"
-    method_option :namespace, type: :string, aliases: "-n"
-    method_option :environment, type: :string, aliases: "-e"
-    method_option :image_tag, type: :string, aliases: "-t"
-    method_option :configmap_path, type: :string, aliases: "-c"
-    method_option :secrets_path, type: :string, aliases: "-s"
-    method_option :output_dir, type: :string, aliases: "-o"
-    def rollback
-      Deployment.rollback(options)
+    if Kubert.ky_active?
+      desc "deploy", "Perform a deployment"
+      method_option :namespace, type: :string, aliases: "-n"
+      method_option :environment, type: :string, aliases: "-e"
+      method_option :image_tag, type: :string, aliases: "-t"
+      method_option :configmap_path, type: :string, aliases: "-c"
+      method_option :secrets_path, type: :string, aliases: "-s"
+      method_option :output_dir, type: :string, aliases: "-o"
+      def deploy
+        Deployment.perform(options)
+      end
+
+      desc "rollback", "Rollback a deployment, reverse of a kubert deploy command with same flags"
+      method_option :namespace, type: :string, aliases: "-n"
+      method_option :environment, type: :string, aliases: "-e"
+      method_option :image_tag, type: :string, aliases: "-t"
+      method_option :configmap_path, type: :string, aliases: "-c"
+      method_option :secrets_path, type: :string, aliases: "-s"
+      method_option :output_dir, type: :string, aliases: "-o"
+      def rollback
+        Deployment.rollback(options)
+      end
     end
 
     Kubert.contexts.each do |context_name, context_endpoint|

data/lib/kubert/deployment.rb

@@ -8,7 +8,7 @@ module Kubert
       new(options).rollback
     end
 
-    attr_reader :project_name, :deployments, :options
+    attr_reader :project_name, :deployments, :options, :operation_statuses
     def initialize(options, project_name= Kubert.configuration[:project_name])
       @project_name = project_name
       @deployments = []
@@ -16,18 +16,22 @@ module Kubert
     end
 
     def rollback
-      confirm "rollback" do
+      confirm :rollback do
         compilation.deploy_generation.proc_commands.keys.each do |deployment_name|
-          `kubectl rollout status deployment/#{deployment_name} #{namespace_flag}` unless excluded?(deployment_name)
+          perform_with_status { `kubectl rollout status deployment/#{deployment_name} #{namespace_flag}` } unless excluded?(deployment_name)
         end
+        report_status(:rollback)
       end
     end
 
     def perform
-      confirm "deploy" do
+      confirm :deploy do
+        perform_with_status { `kubectl apply -f #{output_dir}/#{Kubert.configuration[:project_name]}#{KY::Manipulation::CONFIG_SUFFIX}` }
+        perform_with_status {`kubectl apply -f #{output_dir}/#{Kubert.configuration[:project_name]}#{KY::Manipulation::SECRET_SUFFIX}` }
         compilation.deploy_generation.to_h.each do |deployment_file, _template_hash|
-          `kubectl apply -f #{deployment_file}` unless excluded?(deployment_file)
+          perform_with_status { `kubectl apply -f #{deployment_file}` unless excluded?(deployment_file) }
         end
+        report_status(:deploy)
       end
     end
 
@@ -39,16 +43,28 @@ module Kubert
 
     def confirm(action)
       unless ENV['SKIP_CONFIRMATION']
-        puts "Press any key to confirm, ctl-c to abort: #{action.upcase} on #{Kubert.context}"
-        confirmation = $stdin.gets
+        puts "Press any key to confirm, ctl-c to abort: #{action.to_s.upcase} on #{Kubert.context}"
+        $stdin.gets
       end
       yield
     end
 
+    def report_status(action)
+      puts "All #{action} steps ran successfully"
+    end
+
+    def perform_with_status
+      output = yield
+      abort(output) unless $?.success?
+    end
+
     def options_with_defaults
       (options[:environment] ? options : options.merge(environment: Kubert.default_environment)).with_indifferent_access
     end
 
+    def ky_configuration
+      @ky_configuration ||= compilation.deploy_generation.configuration.configuration.with_indifferent_access
+    end
 
     def namespace_flag
       return unless compilation.configuration[:environment]
@@ -58,5 +74,9 @@ module Kubert
     def excluded?(deployment_info)
       Kubert.excluded_deployments.any? {|deploy| deployment_info.match(deploy) }
     end
+
+    def output_dir
+      compilation.deploy_generation.full_output_dir
+    end
   end
 end

data/lib/kubert/version.rb

@@ -1,3 +1,3 @@
 module Kubert
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kubert
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Brian Glusman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-28 00:00:00.000000000 Z
+date: 2017-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor