seira 0.1.7 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ff2eb0fe8f04aa7734da72c7f0542c7d5b556b84
-  data.tar.gz: 662cee51d65fc44ad8010b4dd3dfdc29b644de6b
+  metadata.gz: 47534b5b777df0da7544ab1c9cbc1b426b336cbc
+  data.tar.gz: b562613300bc8f11a2639885a2cd957f1b97bd26
 SHA512:
-  metadata.gz: dc8e4d479761c4c4f3e09b2b56d0d2e70aca3295fceab18316f56751030b0cee4291a26c5dc9eeec00fcf1d2d1abdba5f47e945c06fdd440e3f861f069eacd14
-  data.tar.gz: 47e734d06b5456df2f54497fb9efe7f02f44f02c7f54de12dc7ce2e8287c69a512cda8f3c96d3c68ea92fd4042149736292a650faafec4bb5c45ededd4ab7995
+  metadata.gz: 3940d87ebf4736b7af53dfa609817757eae92d8c3b8b5284cf5437ea67d46dfc521e4e7911ed8613c3b3f2ac1a9d21da7c8ee27563b5af928391671ecba3ba54
+  data.tar.gz: ca321c84dbe5b482adaa486b1d9b3ec9ef73b03911c2714601b3ce61440dcb2f4fb1fd5fa107ca523a7631c066c159cc46ec06bf055d6b3a2dbf5f7b683c95c9

data/README.md

@@ -70,9 +70,11 @@ seira:
       cluster: gke_org-production_us-central1-a_production
       aliases:
         - "p"
-  valid_apps:
-    - app1
-    - app2
+  applications:
+    - name: app1
+      golden_tier: "web"
+    - name: app2
+      golden_tier: "web"
 ```
 
 This specification is read in and used to determine what `gcloud` context to use and what `kubectl` cluster to use when operating commands. For example, `seira internal` will connect to `org-internal` gcloud configuration and `gke_org-internal_us-central1-a_internal` kubectl cluster. For shorthand, `seira i` shorthand is specified as an alias.

data/lib/helpers.rb

@@ -0,0 +1,13 @@
+module Seira
+  class Helpers
+    class << self
+      def rails_env(context:)
+        if context[:cluster] == 'internal'
+          'production'
+        else
+          context[:cluster]
+        end
+      end
+    end
+  end
+end

data/lib/seira.rb

@@ -1,12 +1,14 @@
 require 'json'
 require 'highline/import'
 require 'colorize'
+require 'tmpdir'
 
 require "seira/version"
 require 'seira/app'
 require 'seira/cluster'
 require 'seira/memcached'
 require 'seira/pods'
+require 'seira/jobs'
 require 'seira/proxy'
 require 'seira/random'
 require 'seira/db'
@@ -22,6 +24,7 @@ module Seira
     CATEGORIES = {
       'secrets' => Seira::Secrets,
       'pods' => Seira::Pods,
+      'jobs' => Seira::Jobs,
       'db' => Seira::Db,
       'redis' => Seira::Redis,
       'memcached' => Seira::Memcached,
@@ -104,6 +107,7 @@ module Seira
       {
         cluster: cluster,
         project: project,
+        settings: settings,
         default_zone: settings.default_zone
       }
     end
@@ -118,7 +122,7 @@ module Seira
     def perform_action_validation(klass:, action:)
       return true if simple_cluster_change?
 
-      unless klass == Seira::Cluster || settings.valid_apps.include?(app)
+      unless klass == Seira::Cluster || settings.applications.include?(app)
         puts "Invalid app name specified"
         exit(1)
       end

data/lib/seira/app.rb

@@ -49,6 +49,13 @@ module Seira
       run_apply(restart: true)
     end
 
+    def ask_cluster_for_current_revision
+      tier = context[:settings].config_for_app(app)['golden_tier'] || 'web'
+      current_image = `kubectl get deployment --namespace=#{app} -l app=#{app},tier=#{tier} -o=jsonpath='{$.items[:1].spec.template.spec.containers[:1].image}'`.strip.chomp
+      current_revision = current_image.split(':').last
+      current_revision
+    end
+
     private
 
     def run_bootstrap
@@ -64,39 +71,40 @@ module Seira
 
     # Kube vanilla based upgrade
     def run_apply(restart: false)
-      destination = "tmp/#{context[:cluster]}/#{app}"
-      revision = ENV['REVISION']
-
-      if revision.nil?
-        current_image = `kubectl get deployment --namespace=#{app} -l app=#{app},tier=web -o=jsonpath='{$.items[:1].spec.template.spec.containers[:1].image}'`.strip.chomp
-        current_revision = current_image.split(':').last
-        exit(1) unless HighLine.agree("No REVISION specified. Use current deployment revision '#{current_revision}'?")
-        revision = current_revision
-      end
+      Dir.mktmpdir do |dir|
+        destination = "#{dir}/#{context[:cluster]}/#{app}"
+        revision = ENV['REVISION']
+
+        if revision.nil?
+          current_revision = ask_cluster_for_current_revision
+          exit(1) unless HighLine.agree("No REVISION specified. Use current deployment revision '#{current_revision}'?")
+          revision = current_revision
+        end
 
-      replacement_hash = {
-        'REVISION' => revision,
-        'RESTARTED_AT_VALUE' => "Initial Deploy for #{revision}"
-      }
+        replacement_hash = {
+          'REVISION' => revision,
+          'RESTARTED_AT_VALUE' => "Initial Deploy for #{revision}"
+        }
 
-      if restart
-        replacement_hash['RESTARTED_AT_VALUE'] = Time.now.to_s
-      end
+        if restart
+          replacement_hash['RESTARTED_AT_VALUE'] = Time.now.to_s
+        end
 
-      replacement_hash.each do |k, v|
-        next unless v.nil? || v == ''
-        puts "Found nil or blank value for replacement hash key #{k}. Aborting!"
-        exit(1)
-      end
+        replacement_hash.each do |k, v|
+          next unless v.nil? || v == ''
+          puts "Found nil or blank value for replacement hash key #{k}. Aborting!"
+          exit(1)
+        end
 
-      find_and_replace_revision(
-        source: "kubernetes/#{context[:cluster]}/#{app}",
-        destination: destination,
-        replacement_hash: replacement_hash
-      )
+        find_and_replace_revision(
+          source: "kubernetes/#{context[:cluster]}/#{app}",
+          destination: destination,
+          replacement_hash: replacement_hash
+        )
 
-      puts "Running 'kubectl apply -f #{destination}'"
-      system("kubectl apply -f #{destination}")
+        puts "Running 'kubectl apply -f #{destination}'"
+        system("kubectl apply -f #{destination}")
+      end
     end
 
     def run_scale
@@ -128,12 +136,7 @@ module Seira
       main_secret_name = Seira::Secrets.new(app: app, action: action, args: args, context: context).main_secret_name
 
       # 'internal' is a unique cluster/project "cluster". It always means production in terms of rails app.
-      rails_env =
-        if context[:cluster] == 'internal'
-          'production'
-        else
-          context[:cluster]
-        end
+      rails_env = Helpers.rails_env(context: context)
 
       puts `kubectl create secret generic #{main_secret_name} --namespace #{app} --from-literal=RAILS_ENV=#{rails_env} --from-literal=RACK_ENV=#{rails_env}`
     end
@@ -153,16 +156,26 @@ module Seira
     end
 
     def find_and_replace_revision(source:, destination:, replacement_hash:)
-      puts "Copying source yaml from #{source} to #{destination}"
+      puts "Copying source yaml from #{source} to temp folder"
       FileUtils.mkdir_p destination # Create the nested directory
       FileUtils.rm_rf("#{destination}/.", secure: true) # Clean out old files from the tmp folder
       FileUtils.copy_entry source, destination
+      # Anything in jobs directory is not intended to be applied when deploying
+      # the app, but rather ran when needed as Job objects. Force to avoid exception if DNE.
+      FileUtils.rm_rf("#{destination}/jobs/") if File.directory?("#{destination}/jobs/")
 
       # Iterate through each yaml file and find/replace and save
-      puts "Iterating #{destination} files find/replace revision information"
+      puts "Iterating temp folder files find/replace revision information"
       Dir.foreach(destination) do |item|
         next if item == '.' || item == '..'
 
+        # If we have run into a directory item, skip it
+        next if File.directory?("#{destination}/#{item}")
+
+        # Skip any manifest file that has "seira-skip.yaml" at the end. Common use case is for Job definitions
+        # to be used in "seira staging <app> jobs run"
+        next if item.end_with?("seira-skip.yaml")
+
         text = File.read("#{destination}/#{item}")
 
         new_contents = text

data/lib/seira/cluster.rb

@@ -5,7 +5,7 @@ require 'fileutils'
 # Example usages:
 module Seira
   class Cluster
-    VALID_ACTIONS = %w[help bootstrap].freeze
+    VALID_ACTIONS = %w[help bootstrap upgrade].freeze
     SUMMARY = "For managing whole clusters.".freeze
 
     attr_reader :action, :args, :context, :settings
@@ -23,6 +23,8 @@ module Seira
         run_help
       when 'bootstrap'
         run_bootstrap
+      when 'upgrade'
+        run_upgrade
       else
         fail "Unknown command encountered"
       end
@@ -78,5 +80,129 @@ module Seira
       puts `kubectl create secret docker-registry gcr-secret --docker-username=_json_key --docker-password="$(cat #{dockercfg_location})" --docker-server=https://gcr.io --docker-email=doesnotmatter@example.com`
       puts `kubectl create secret generic cloudsql-credentials --namespace default --from-file=credentials.json=#{cloudsql_credentials_location}`
     end
+
+    def run_upgrade
+      cluster = context[:cluster]
+
+      # Take a single argument, which is the version to upgrade to
+      new_version = args[0]
+      if new_version.nil?
+        puts 'must specify version to upgrade to'
+        exit(1)
+      end
+
+      # Ensure the specified version is supported by GKE
+      server_config = JSON.parse(`gcloud container get-server-config --format json`)
+      valid_versions = server_config['validMasterVersions']
+      unless valid_versions.include? new_version
+        puts "Version #{new_version} is unsupported. Supported versions are:"
+        puts valid_versions
+        exit(1)
+      end
+
+      cluster_config = JSON.parse(`gcloud container clusters describe #{cluster} --format json`)
+
+      # Update the master node first
+      puts 'updating master (this may take a while)'
+      if cluster_config['currentMasterVersion'] == new_version
+        # Master has already been updated; this step is not needed
+        puts 'already up to date'
+      elsif system("gcloud container clusters upgrade #{cluster} --cluster-version=#{new_version} --master")
+        puts 'master updated successfully'
+      else
+        puts 'failed to update master'
+        exit(1)
+      end
+
+      # Figure out what our current node pool setup is. The goal here is to be able to re-run this
+      # command if it fails partway through, and have it pick up where it left off.
+      pools = JSON.parse(`gcloud container node-pools list --cluster #{cluster} --format json`)
+      if pools.length == 2
+        # We have two node pools. Assume this is due to the upgrade process already being started,
+        # so we have one pool with the old version and one pool with the new version.
+        old_pool = pools.find { |p| p['version'] != new_version }
+        new_pool = pools.find { |p| p['version'] == new_version }
+        if old_pool.nil? || new_pool.nil?
+          # Turns out the two pools are not the result of a partially-finished upgrade; in this
+          # case we give up and the upgrade will have to proceed manually.
+          puts 'Unsupported node pool setup: could not find old and new pool'
+          exit(1)
+        end
+      elsif pools.length == 1
+        # Only one pool is the normal case; set old_pool and that's it.
+        old_pool = pools.first
+      else
+        # If we have three or more or zero pools, upgrade will have to proceed manually.
+        puts 'Unsupported node pool setup: unexpected number of pools'
+        exit(1)
+      end
+      # Get names of the nodes in the old node pool
+      old_nodes = `kubectl get nodes -l cloud.google.com/gke-nodepool=#{old_pool['name']} -o name`.split("\n")
+
+      # If we don't already have a new pool (i.e. one with the new version), create one
+      if new_pool.nil?
+        # Pick a name for the new pool, alternating between blue and green
+        new_pool_name = old_pool['name'] == 'blue' ? 'green' : 'blue'
+
+        # Create a new node pool with all the same settings as the old one. The version of the new
+        # pool will match the master version, which has already been updated.
+        puts 'creating new node pool'
+        command =
+          "gcloud container node-pools create #{new_pool_name} \
+          --cluster=#{cluster} \
+          --disk-size=#{old_pool['config']['diskSizeGb']} \
+          --image-type=#{old_pool['config']['imageType']} \
+          --machine-type=#{old_pool['config']['machineType']} \
+          --num-nodes=#{old_nodes.count} \
+          --service-account=#{old_pool['serviceAccount']}"
+        # TODO: support autoscaling if old pool has it turned on
+        if system(command)
+          puts 'new pool created successfully'
+        else
+          puts 'failed to create new pool'
+          exit(1)
+        end
+      end
+
+      # Cordon all the nodes in the old pool, preventing new workloads from being sent to them
+      puts 'cordoning old nodes'
+      old_nodes.each do |node|
+        unless system("kubectl cordon #{node}")
+          puts "failed to cordon node #{node}"
+          exit(1)
+        end
+      end
+
+      # Drain all the nodes in the old pool, moving workloads off of them gradually while
+      # respecting maxUnavailable etc.
+      puts 'draining old nodes'
+      old_nodes.each do |node|
+        # --force deletes pods that aren't managed by a ReplicationController, Job, or DaemonSet,
+        #   which shouldn't be any besides manually created temp pods
+        # --ignore-daemonsets prevents failing due to presence of DaemonSets, which cannot be moved
+        #   because they're tied to a specific node
+        # --delete-local-data prevents failing due to presence of local data, which cannot be moved
+        #   but is bad practice to use for anything that can't be lost
+        puts "draining #{node}"
+        unless system("kubectl drain --force --ignore-daemonsets --delete-local-data #{node}")
+          puts "failed to drain node #{node}"
+          exit(1)
+        end
+      end
+
+      # All workloads which can be moved have been moved off of old node pool have been moved, so
+      # that node pool can be deleted, leaving only the new pool with the new version
+      if HighLine.agree('Delete old node pool?')
+        puts 'deleting old node pool'
+        if system("gcloud container node-pools delete #{old_pool['name']} --cluster #{cluster}")
+          puts 'old pool deleted successfully'
+        else
+          puts 'failed to delete old pool'
+          exit(1)
+        end
+      end
+
+      puts 'upgrade complete!'
+    end
   end
 end

data/lib/seira/db/create.rb

@@ -61,6 +61,8 @@ module Seira
             @replica_for = arg.split('=')[1] # TODO: Read secret to get it automatically, but allow for fallback
           elsif arg.start_with? '--highly-available'
             @make_highly_available = true
+          elsif arg.start_with? '--database-name='
+            @database_name = arg.split('=')[1]
           elsif /^--[\w\-]+=.+$/.match? arg
             create_command += " #{arg}"
           else
@@ -195,6 +197,10 @@ module Seira
         name.gsub("handshake-", "")
       end
 
+      def default_database_name
+        "#{app}_#{Helpers.rails_env(context: context)}"
+      end
+
       def write_pgbouncer_yaml
         # TODO: Clean this up by moving into a proper templated yaml file
         pgbouncer_yaml = <<-FOO
@@ -244,7 +250,7 @@ spec:
         database: #{name}
     spec:
       containers:
-        - image: handshake/pgbouncer:0.1.2
+        - image: handshake/pgbouncer:0.2.0
           name: pgbouncer
           ports:
             - containerPort: 6432
@@ -254,9 +260,14 @@ spec:
                 name: #{pgbouncer_configs_name}
             - secretRef:
                 name: #{pgbouncer_secret_name}
+          env:
+            - name: "PGPORT"
+              value: "6432"
+            - name: "PGDATABASE"
+              value: "#{@database_name || default_database_name}"
           readinessProbe:
-            tcpSocket:
-              port: 6432
+            exec:
+              command: ["psql", "-c", "SELECT 1;"]
             initialDelaySeconds: 5
             periodSeconds: 10
           livenessProbe:

data/lib/seira/jobs.rb

@@ -0,0 +1,145 @@
+require 'json'
+
+module Seira
+  class Jobs
+    VALID_ACTIONS = %w[help list delete run].freeze
+    SUMMARY = "Manage your application's jobs.".freeze
+
+    attr_reader :app, :action, :args, :job_name, :context
+
+    def initialize(app:, action:, args:, context:)
+      @app = app
+      @action = action
+      @context = context
+      @args = args
+      @job_name = args[0]
+    end
+
+    def run
+      case action
+      when 'help'
+        run_help
+      when 'list'
+        run_list
+      when 'delete'
+        run_delete
+      when 'run'
+        run_run
+      else
+        fail "Unknown command encountered"
+      end
+    end
+
+    private
+
+    def run_help
+      puts SUMMARY
+      puts "\n\n"
+      puts "TODO"
+    end
+
+    def run_list
+      puts `kubectl get jobs --namespace=#{app} -o wide`
+    end
+
+    def run_delete
+      puts `kubectl delete job #{job_name} --namespace=#{app}`
+    end
+
+    def run_run
+      gcp_app = App.new(app: app, action: 'apply', args: [""], context: context)
+
+      # Set defaults
+      async = false # Wait for job to finish before continuing.
+      no_delete = false # Delete at end
+
+      # Loop through args and process any that aren't just the command to run
+      loop do
+        arg = args.first
+        if arg.nil?
+          puts 'Please specify a command to run'
+          exit(1)
+        end
+
+        break unless arg.start_with? '--'
+
+        if arg == '--async'
+          async = true
+        elsif arg == '--no-delete'
+          no_delete = true
+        else
+          puts "Warning: Unrecognized argument #{arg}"
+        end
+
+        args.shift
+      end
+
+      if async && !no_delete
+        puts "Cannot delete Job after running if Job is async, since we don't know when it finishes."
+        exit(1)
+      end
+
+      # TODO: Configurable CPU and memory by args such as large, small, xlarge.
+      command = args.join(' ')
+      unique_name = "#{app}-run-#{Random.unique_name}"
+      revision = gcp_app.ask_cluster_for_current_revision # TODO: Make more reliable, especially with no web tier
+      replacement_hash = {
+        'UNIQUE_NAME' => unique_name,
+        'REVISION' => revision,
+        'COMMAND' => command.split(' ').map { |part| "\"#{part}\"" }.join(", "),
+        'CPU_REQUEST' => '200m',
+        'CPU_LIMIT' => '500m',
+        'MEMORY_REQUEST' => '500Mi',
+        'MEMORY_LIMIT' => '1Gi',
+      }
+
+      source = "kubernetes/#{context[:cluster]}/#{app}" # TODO: Move to method in app.rb
+      Dir.mktmpdir do |destination|
+        revision = ENV['REVISION']
+        file_name = "template.yaml"
+
+        FileUtils.mkdir_p destination # Create the nested directory
+        FileUtils.copy_file "#{source}/jobs/#{file_name}", "#{destination}/#{file_name}"
+
+        # TOOD: Move this into a method since it is copied from app.rb
+        text = File.read("#{destination}/#{file_name}")
+        new_contents = text
+        replacement_hash.each do |key, value|
+          new_contents.gsub!(key, value)
+        end
+        File.open("#{destination}/#{file_name}", 'w') { |file| file.write(new_contents) }
+
+        puts "Running 'kubectl apply -f #{destination}'"
+        system("kubectl apply -f #{destination}")
+      end
+
+      unless async
+        # Check job status until it's finished
+        print 'Waiting for job to complete...'
+        job_spec = nil
+        loop do
+          job_spec = JSON.parse(`kubectl --namespace=#{app} get job #{unique_name} -o json`)
+          break if !job_spec['status']['succeeded'].nil? || !job_spec['status']['failed'].nil?
+          print '.'
+          sleep 3
+        end
+
+        status =
+          if !job_spec['status']['succeeded'].nil?
+            "succeeded"
+          elsif !job_spec['status']['failed'].nil?
+            "failed"
+          else
+            "unknown"
+          end
+
+        if no_delete
+          puts "Job finished with status #{status}. Leaving Job object in cluster, clean up manually when confirmed."
+        else
+          print "Job finished with status #{status}. Deleting Job from cluster for cleanup."
+          system("kubectl delete job #{unique_name} -n #{app}")
+        end
+      end
+    end
+  end
+end

data/lib/seira/memcached.rb

@@ -103,12 +103,12 @@ module Seira
         end
       end
 
-      file_name = write_config(values)
-      unique_name = Seira::Random.unique_name(existing_instances)
-      name = "#{app}-memcached-#{unique_name}"
-      puts `helm install --namespace #{app} --name #{name} --wait -f #{file_name} stable/memcached`
-
-      File.delete(file_name)
+      Dir.mktmpdir do |dir|
+        file_name = write_config(dir: dir, values: values)
+        unique_name = Seira::Random.unique_name(existing_instances)
+        name = "#{app}-memcached-#{unique_name}"
+        puts `helm install --namespace #{app} --name #{name} --wait -f #{file_name} stable/memcached`
+      end
 
       puts "To get status: 'seira #{context[:cluster]} #{app} memcached status #{unique_name}'"
       puts "Service URI for this memcached instance: 'memcached://#{name}-memcached:11211'."
@@ -131,8 +131,8 @@ module Seira
       end
     end
 
-    def write_config(values)
-      file_name = "tmp/temp-memcached-config-#{Seira::Cluster.current_cluster}-#{app}.json"
+    def write_config(dir:, values:)
+      file_name = "#{dir}/temp-memcached-config-#{Seira::Cluster.current_cluster}-#{app}.json"
       File.open(file_name, "wb") do |f|
         f.write(values.to_json)
       end

data/lib/seira/redis.rb

@@ -122,12 +122,12 @@ module Seira
         end
       end
 
-      file_name = write_config(values)
-      unique_name = Seira::Random.unique_name(existing_instances)
-      name = "#{app}-redis-#{unique_name}"
-      puts `helm install --namespace #{app} --name #{name} --wait -f #{file_name} stable/redis`
-
-      File.delete(file_name)
+      Dir.mktmpdir do |dir|
+        file_name = write_config(dir: dir, values: values)
+        unique_name = Seira::Random.unique_name(existing_instances)
+        name = "#{app}-redis-#{unique_name}"
+        puts `helm install --namespace #{app} --name #{name} --wait -f #{file_name} stable/redis`
+      end
 
       puts "To get status: 'seira #{context[:cluster]} #{app} redis status #{unique_name}'"
       puts "To get credentials for storing in app secrets: 'seira #{context[:cluster]} #{app} redis credentials #{unique_name}'"
@@ -151,8 +151,8 @@ module Seira
       end
     end
 
-    def write_config(values)
-      file_name = "tmp/temp-redis-config-#{Seira::Cluster.current_cluster}-#{app}.json"
+    def write_config(dir:, values:)
+      file_name = "#{dir}/temp-redis-config-#{Seira::Cluster.current_cluster}-#{app}.json"
       File.open(file_name, "wb") do |f|
         f.write(values.to_json)
       end

data/lib/seira/secrets.rb

@@ -138,22 +138,22 @@ module Seira
     # In the normal case the secret we are updating is just main_secret_name,
     # but in special cases we may be doing an operation on a different secret
     def write_secrets(secrets:, secret_name: main_secret_name)
-      file_name = "tmp/temp-secrets-#{Seira::Cluster.current_cluster}-#{secret_name}.json"
-      File.open(file_name, "wb") do |f|
-        f.write(secrets.to_json)
+      Dir.mktmpdir do |dir|
+        file_name = "#{dir}/temp-secrets-#{Seira::Cluster.current_cluster}-#{secret_name}.json"
+        File.open(file_name, "w") do |f|
+          f.write(secrets.to_json)
+        end
+
+        # The command we use depends on if it already exists or not
+        secret_exists = system("kubectl get secret #{secret_name} --namespace #{app} > /dev/null")
+        command = secret_exists ? "replace" : "create"
+
+        if system("kubectl #{command} --namespace #{app} -f #{file_name}")
+          puts "Successfully created/replaced #{secret_name} secret #{key} in cluster #{Seira::Cluster.current_cluster}"
+        else
+          puts "Failed to update secret"
+        end
       end
-
-      # The command we use depends on if it already exists or not
-      secret_exists = system("kubectl get secret #{secret_name} --namespace #{app} > /dev/null")
-      command = secret_exists ? "replace" : "create"
-
-      if system("kubectl #{command} --namespace #{app} -f #{file_name}")
-        puts "Successfully created/replaced #{secret_name} secret #{key} in cluster #{Seira::Cluster.current_cluster}"
-      else
-        puts "Failed to update secret"
-      end
-
-      File.delete(file_name)
     end
 
     # Returns the still-base64encoded secrets hashmap

data/lib/seira/settings.rb

@@ -24,8 +24,12 @@ module Seira
       settings['seira']['default_zone']
     end
 
-    def valid_apps
-      settings['seira']['valid_apps']
+    def applications
+      settings['seira']['applications'].map { |app| app['name'] }
+    end
+
+    def config_for_app(app_name)
+      settings['seira']['applications'].find { |app| app['name'] == app_name }
     end
 
     def valid_cluster_names

data/lib/seira/version.rb

@@ -1,3 +1,3 @@
 module Seira
-  VERSION = "0.1.7".freeze
+  VERSION = "0.2.0".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: seira
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.2.0
 platform: ruby
 authors:
 - Scott Ringwelski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-02 00:00:00.000000000 Z
+date: 2018-01-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: highline
@@ -116,11 +116,13 @@ files:
 - bin/console
 - bin/seira
 - bin/setup
+- lib/helpers.rb
 - lib/seira.rb
 - lib/seira/app.rb
 - lib/seira/cluster.rb
 - lib/seira/db.rb
 - lib/seira/db/create.rb
+- lib/seira/jobs.rb
 - lib/seira/memcached.rb
 - lib/seira/pods.rb
 - lib/seira/proxy.rb