ky 0.3.2 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5e6457f14235fff459007114725f30bc21c98c8e
-  data.tar.gz: 79e288a71402fed10584f55ca4c1dccac9cb6c28
+  metadata.gz: 2533ddef5c84d343f63a450906ff204af9d8fba3
+  data.tar.gz: fa69c9106ed34e68b7d37b0ae42d6a038133967d
 SHA512:
-  metadata.gz: 8d24974efdd05b58bdd32483ab43e5bac1f0b7be4c87100105cb10751d119c555f1691fa0c6a6b6f208cefd18bf72d526eaecda4f61f6bca614c76598cb5f86d
-  data.tar.gz: 0a3cb75f0eb527b1ecc8efe997551a61665d50936af73a0a547f1cbd9231004428b1980402bbe217106c5b33d0b6c6cbeb5a034e597223eab20d335ab01896b1
+  metadata.gz: 56c897b7045750693622757feeac1920b395a17258d92096151811a5df8f6dc59dcd1f2447a83c5733a92a630c84410174fe65216ee6d68c06b654d27e5d5254
+  data.tar.gz: 3bd1693ec6df03cd29733abdda68369b85e6ee5442402a2a2331e14a666f46df874d9ad7655974753287698fed631ada2d5968601dd6fc1cdfab0d9551ef39a0

data/README.md

@@ -7,7 +7,7 @@ The primary purpose is to automate/DRY up duplication and agreement between mult
 The full/hopeful use of the tool may be enabled with the new `compile` command which is very much a rough draft at present, but which takes a crack at generating a complete deployment yaml file for every line of a Procfile such as used for Heroku, and a pair of config and secrets files.  The secret file can be non-base64 encoded, and compile will generate deployments and a base64 encoded secrets file to a target directory specified.  This command uses all the below commands in combination, one other command not exposed via CLI independently.
 
 The command is invoked as:
-`ky compile Procfile.file config.yml secrets.yml output_dir` and the output directory will be created if necessary.  You may pass a namespace to compile which will be reflected in the deployments (and should agree with the config and secrets, though it's not checking they agree at present).  The arguments are all configurable via the configuration file as well, so it can in practice be invoked as `ky compile` or `kky compile --envioronment stg` if you have a configuration file correctly present as described below.
+`ky compile Procfile.file config.yml secrets.yml output_dir` and the output directory will be created if necessary.  You may pass a namespace to compile which will be reflected in the deployments (and should agree with the config and secrets, though it's not checking they agree at present).  The arguments are all configurable via the configuration file as well, so it can in practice be invoked as `ky compile` or `ky compile --envioronment stg` if you have a configuration file correctly present as described below.
 
 Configuration begins with a config file in the project working directory, or in your home directory if you wish to share across several projects.  Unfortunately there are several competing conventions for configuration files, the traditional dot-file configuration convention and newer, more visible Capitalfile configuration.  KY is a lubricant, and has no opinion, and therefore currently supports naming your configuration file `.ky.yml`, `.ky.yaml`, or `Lubefile` or `Kyfile`.  The default configuration, if this file is not found, is as follows:
 ```

data/lib/ky.rb

@@ -9,7 +9,7 @@ require_relative 'ky/template'
 require_relative 'ky/deploy_generation'
 
 
-module KY
+class KY
   CONFIG_FILE_NAMES = [".ky.yml", ".ky.yaml", "Lubefile", "Kyfile"]
   CONFIG_LOCATIONS = ["#{Dir.pwd}/", "#{Dir.home}/"]
   DEFAULT_CONFIG = {
@@ -23,10 +23,9 @@ module KY
     inline_config: true,
     inline_secret: false,
     project_name: "global"
-  }.stringify_keys
+  }.with_indifferent_access
 
-  module_function
-  cattr_accessor :environment, :image_tag
+  attr_accessor :environment, :image_tag
 
   def decode(output, input)
     output << Manipulation.code_yaml(input, :decode)
@@ -41,7 +40,7 @@ module KY
   end
 
   def env(output, input1, input2)
-    output << EnvGeneration.generate_env(input1, input2).to_yaml
+    output << EnvGeneration.generate_env(self, input1, input2).to_yaml
   rescue KY::EnvGeneration::ConflictingProjectError => e
     $stderr << "Error processing yml files, please provide a config and a secrets file from the same kubernetes project/name"
     exit(1)
@@ -50,12 +49,12 @@ module KY
   def compile(proc_path, env1path, env2path, base_output_dir, namespace=DeployGeneration::DEFAULT_NAMESPACE)
     full_output_dir = Pathname.new(base_output_dir).join(environment.to_s).to_s
     FileUtils.mkdir_p(full_output_dir)
-    env_obj = EnvGeneration.new(env1path, env2path)
-    deploys_hash = DeployGeneration.new(proc_path, full_output_dir, env_obj.project, namespace).to_h
+    env_obj = EnvGeneration.new(self, env1path, env2path)
+    deploys_hash = DeployGeneration.new(self, proc_path, full_output_dir, env_obj.project, namespace).to_h
     deploys_hash.each do |file_path, deploy_hash|
       File.write(file_path, Manipulation.merge_hash(deploy_hash, env_obj.to_h).to_yaml)
     end
-    Manipulation.write_configs_encode_if_needed(env_obj.config_hsh, env_obj.secret_hsh, full_output_dir, configuration["project_name"])
+    Manipulation.write_configs_encode_if_needed(env_obj.config_hsh, env_obj.secret_hsh, full_output_dir, configuration[:project_name])
   end
 
   def configuration

data/lib/ky/cli.rb

@@ -1,33 +1,33 @@
 require_relative '../ky'
 require 'thor'
-module KY
+class KY
   class Cli < Thor
     MissingParametersError = Class.new(StandardError)
     desc "encode secrets.yml", "base64 encoded yaml version of data attributes in secrets.yml"
     def encode(input_source=$stdin, output_source=$stdout)
       input_output(input_source, output_source) do |input_object, output_object|
-        KY.encode(output_object, input_object)
+        KY.new.encode(output_object, input_object)
       end
     end
 
     desc "decode secrets.yml", "decoded yaml version of secrets.yml with base64 encoded data attributes"
     def decode(input_source=$stdin, output_source=$stdout)
       input_output(input_source, output_source) do |input_object, output_object|
-        KY.decode(output_object, input_object)
+        KY.new.decode(output_object, input_object)
       end
     end
 
     desc "merge base.yml env.yml", "deep merged/combined yaml of two seperate files"
     def merge(input_source1, input_source2=$stdin, output_source=$stdout)
       input_output(input_source1, output_source) do |input_object1, output_object|
-        with(input_source2, 'r') {|input_object2| KY.merge(output_object, input_object1, input_object2) }
+        with(input_source2, 'r') {|input_object2| KY.new.merge(output_object, input_object1, input_object2) }
       end
     end
 
     desc "env config.yml secrets.yml", "generate env variables section of a deployment from a config and a secrets file"
     def env(input_source1, input_source2=$stdin, output_source=$stdout)
       input_output(input_source1, output_source) do |input_object1, output_object|
-        with(input_source2, 'r') {|input_object2| KY.env(output_object, input_object1, input_object2) }
+        with(input_source2, 'r') {|input_object2| KY.new.env(output_object, input_object1, input_object2) }
       end
     end
 
@@ -43,15 +43,16 @@ module KY
     method_option :environment, type: :string, aliases: "-e"
     method_option :image_tag, type: :string, aliases: "-t"
     def compile(procfile_path=nil, config_or_secrets_path=nil, secrets_or_config_path=nil, output_dir=nil)
-      KY.environment = options[:environment]
-      KY.image_tag   = options[:image_tag]
-      procfile_path ||= KY.configuration['procfile_path']
-      config_or_secrets_path  ||= KY.configuration['config_path'] || KY.configuration['secret_path']
-      secrets_or_config_path  ||= KY.configuration['secret_path'] || KY.configuration['config_path']
-      output_dir ||= KY.configuration['output_dir']
+      instance = KY.new
+      instance.environment = options[:environment]
+      instance.image_tag   = options[:image_tag]
+      procfile_path ||= instance.configuration['procfile_path']
+      config_or_secrets_path  ||= instance.configuration['config_path'] || instance.configuration['secret_path']
+      secrets_or_config_path  ||= instance.configuration['secret_path'] || instance.configuration['config_path']
+      output_dir ||= instance.configuration['output_dir']
       raise MissingParametersError unless procfile_path && config_or_secrets_path && secrets_or_config_path && output_dir
       input_input(config_or_secrets_path, secrets_or_config_path) do |input1, input2|
-        KY.compile(procfile_path, input1, input2, output_dir, options[:namespace])
+        instance.compile(procfile_path, input1, input2, output_dir, options[:namespace])
       end
     end
 

data/lib/ky/deploy_generation.rb

@@ -1,13 +1,14 @@
-module KY
+class KY
   class DeployGeneration
-    def initialize(proc_path, full_output_dir, project_name=nil, current_namespace=nil)
+    def initialize(instance, proc_path, full_output_dir, project_name=nil, current_namespace=nil)
+      @instance = instance
       @proc_commands = File.read(proc_path).split("\n")
                             .map {|line| line.split(':', 2) }
                             .map {|k, v| [k, ["/bin/bash","-c", v]] }
                             .to_h
       @full_output_dir = full_output_dir
-      @project_name = project_name || KY.configuration[:project_name]
-      @current_namespace = current_namespace || KY.configuration[:namespace]
+      @project_name = project_name || instance.configuration[:project_name]
+      @current_namespace = current_namespace || instance.configuration[:namespace]
       @deployment_yaml = read_deployment_yaml
     end
 
@@ -24,11 +25,11 @@ module KY
     end
 
     private
-    attr_reader :proc_commands, :full_output_dir, :project_name, :current_namespace, :deployment_yaml
+    attr_reader :proc_commands, :full_output_dir, :project_name, :current_namespace, :deployment_yaml, :instance
 
     def read_deployment_yaml
-      if KY.configuration['deployment']
-        File.read(KY.configuration['deployment'])
+      if instance.configuration['deployment']
+        File.read(instance.configuration['deployment'])
       else
         File.read(default_deployment_template)
       end
@@ -39,13 +40,13 @@ module KY
     end
 
     def template_hash(id, command_array)
-      app_name =  KY.configuration['app_name'] || "#{project_name}-#{id}"
+      app_name =  instance.configuration['app_name'] || "#{project_name}-#{id}"
       template_context = Template.context(app_name: app_name, id: id, command_array: command_array)
       Manipulation.merge_hash(
         YAML.load(
           ERB.new(deployment_yaml).result(template_context)
         ),
-        KY.deploy_merge(id)
+        instance.deploy_merge(id)
       )
     end
   end

data/lib/ky/env_generation.rb

@@ -1,6 +1,6 @@
 require 'active_support'
 require 'active_support/core_ext'
-module KY
+class KY
   class EnvGeneration
     ConflictingProjectError = Class.new(StandardError)
 
@@ -9,13 +9,14 @@ module KY
       define_method(raw_string.underscore) { raw_string }
     end
 
-    def self.generate_env(input1, input2)
-      new(input1, input2).to_h
+    def self.generate_env(instance, input1, input2)
+      new(instance, input1, input2).to_h
     end
 
-    attr_reader :config_hsh, :secret_hsh
-    def initialize(input1, input2)
+    attr_reader :config_hsh, :secret_hsh, :instance
+    def initialize(instance, input1, input2)
       input_hashes = YAML.load(input1.read), YAML.load(input2.read)
+      @instance = instance
       @config_hsh = input_hashes.find {|h| h[kind] == config_map }
       @secret_hsh = input_hashes.find {|h| h[kind] == secret }
       raise ConflictingProjectError.new("Config and Secret metadata names do not agree") unless secret_hsh[metadata][name] == project
@@ -41,12 +42,12 @@ module KY
     end
 
     def inline_config?
-      KY.configuration[:inline_config]
+      instance.configuration[:inline_config]
     end
 
 
     def inline_secret?
-      KY.configuration[:inline_secret]
+      instance.configuration[:inline_secret]
     end
 
     def inline_env_map(type, kebab_version, env_value)

data/lib/ky/manipulation.rb

@@ -1,5 +1,5 @@
 require 'deep_merge/rails_compat'
-module KY
+class KY
   module Manipulation
     DEFAULT_DATA_KEY = 'data'
     MAGIC_DELIMITER = '@'

data/lib/ky/template.rb

@@ -1,22 +1,24 @@
-class Template
-  def self.context(hsh)
-    new(hsh).context
-  end
+class KY
+  class Template
+    def self.context(hsh)
+      new(hsh).context
+    end
 
-  attr_reader :context_hash
-  def initialize(hsh)
-    @context_hash = hsh
-  end
+    attr_reader :context_hash
+    def initialize(hsh)
+      @context_hash = hsh
+    end
 
-  def environment
-    KY.environment
-  end
+    def environment
+      KY.environment
+    end
 
-  def context
-    template_context = binding
-    context_hash.each do |var, value|
-      template_context.local_variable_set(var, value)
+    def context
+      template_context = binding
+      context_hash.each do |var, value|
+        template_context.local_variable_set(var, value)
+      end
+      template_context
     end
-    template_context
   end
 end

data/lib/ky/version.rb

@@ -1,3 +1,3 @@
-module KY
-  VERSION = "0.3.2"
+class KY
+  VERSION = "0.3.3"
 end

data/spec/ky_bin_spec.rb

@@ -1,79 +1,114 @@
 require 'ky/cli'
-describe "cli commands" do
-  let(:tmpfile_path) { "spec/support/tmpfile.yml" }
-  before do # for backwards compatible with old non-inlining test/support behavior
-    normal_config = KY::DEFAULT_CONFIG
-    KY.define_methods_from_config(normal_config)
-    allow(KY).to receive(:configuration).and_return(normal_config.merge(inline_config: false))
-  end
+describe "ky cli" do
+  describe "legacy/component cli commands" do
+    let(:tmpfile_path) { "spec/support/tmpfile.yml" }
 
-  after { `rm #{tmpfile_path}` if File.exists?(tmpfile_path) }
-  describe "works with stdout" do
-    it "decodes" do
-      output = File.read('spec/support/decoded.yml')
-      expect($stdout).to receive(:<<).with(output)
-      KY::Cli.new.decode("spec/support/encoded.yml")
-    end
+    after { `rm #{tmpfile_path}` if File.exists?(tmpfile_path) }
+    describe "works with stdout" do
+      it "decodes" do
+        output = File.read('spec/support/decoded.yml')
+        expect($stdout).to receive(:<<).with(output)
+        KY::Cli.new.decode("spec/support/encoded.yml")
+      end
 
-    it "encodes" do
-      output = File.read('spec/support/encoded.yml')
-      expect($stdout).to receive(:<<).with(output)
-      KY::Cli.new.encode("spec/support/decoded.yml")
+      it "encodes" do
+        output = File.read('spec/support/encoded.yml')
+        expect($stdout).to receive(:<<).with(output)
+        KY::Cli.new.encode("spec/support/decoded.yml")
+      end
     end
-  end
 
-  describe "works with files" do
-    it "decodes" do
-      output = File.read('spec/support/decoded.yml')
-      KY::Cli.new.decode("spec/support/encoded.yml", tmpfile_path)
-      expect(File.read(tmpfile_path)).to eq(output)
+    describe "works with files" do
+      it "decodes" do
+        output = File.read('spec/support/decoded.yml')
+        KY::Cli.new.decode("spec/support/encoded.yml", tmpfile_path)
+        expect(File.read(tmpfile_path)).to eq(output)
+      end
+
+      it "encodes" do
+        output = File.read('spec/support/encoded.yml')
+        KY::Cli.new.encode("spec/support/decoded.yml", tmpfile_path)
+        expect(File.read(tmpfile_path)).to eq(output)
+      end
     end
 
-    it "encodes" do
-      output = File.read('spec/support/encoded.yml')
-      KY::Cli.new.encode("spec/support/decoded.yml", tmpfile_path)
-      expect(File.read(tmpfile_path)).to eq(output)
+    describe "merges yml files" do
+      it "to stdout" do
+        output = File.read('spec/support/web-merged.yml')
+        expect($stdout).to receive(:<<).with(output)
+        KY::Cli.new.merge('spec/support/web-base.yml', 'spec/support/web-env.yml')
+      end
     end
-  end
 
-  describe "merges yml files" do
-    it "to stdout" do
-      output = File.read('spec/support/web-merged.yml')
-      expect($stdout).to receive(:<<).with(output)
-      KY::Cli.new.merge('spec/support/web-base.yml', 'spec/support/web-env.yml')
+    describe "generates env section" do
+      it "to stdout" do
+        output = File.read('spec/support/web-env.yml')
+        expect($stdout).to receive(:<<).with(output)
+        KY::Cli.new.env('spec/support/decoded.yml', 'spec/support/config.yml')
+      end
+
+      it "config and secret are order independent" do
+        output = File.read('spec/support/web-env.yml')
+        expect($stdout).to receive(:<<).with(output)
+        KY::Cli.new.env('spec/support/config.yml', 'spec/support/decoded.yml')
+      end
+
+      it "to file" do
+        output = File.read('spec/support/web-env.yml')
+        KY::Cli.new.env('spec/support/config.yml', 'spec/support/decoded.yml', tmpfile_path)
+        expect(File.read(tmpfile_path)).to eq(output)
+      end
     end
   end
 
-  describe "generates env section" do
-    it "to stdout" do
-      output = File.read('spec/support/web-env.yml')
-      expect($stdout).to receive(:<<).with(output)
-      KY::Cli.new.env('spec/support/decoded.yml', 'spec/support/config.yml')
+  describe "primary cli command" do
+    let(:instance) { KY.new }
+    let(:fake_tag) { 'fake_tag' }
+    let(:tmpdir) { 'spec/support/tmpdir' }
+    after { `rm -r #{tmpdir}` ; instance.environment = nil ; instance.image_tag = nil }
+    describe "compiles Procfile and env secrets/configs into entire deployments" do
+      it "to directory" do
+        KY::Cli.new.compile('spec/support/Procfile', 'spec/support/config.yml', 'spec/support/decoded.yml', tmpdir)
+        expect(File.exists?("#{tmpdir}/web.deployment.yml")).to be true
+        expect(File.exists?("#{tmpdir}/worker.deployment.yml")).to be true
+        expect(File.exists?("#{tmpdir}/jobs.deployment.yml")).to be true
+      end
     end
 
-    it "config and secret are order independent" do
-      output = File.read('spec/support/web-env.yml')
-      expect($stdout).to receive(:<<).with(output)
-      KY::Cli.new.env('spec/support/config.yml', 'spec/support/decoded.yml')
+    describe "encodes secrets.yml when compiling from Procfile without image_tag" do
+      it "to directory" do
+        instance = KY::Cli.new
+        instance.compile('spec/support/Procfile', 'spec/support/config.yml', 'spec/support/decoded.yml', tmpdir)
+        expect(File.exists?("#{tmpdir}/global.secret.yml")).to be true
+        YAML.load(File.read("#{tmpdir}/global.secret.yml"))['data'].each do |_k, v|
+          expect(v).to match(KY::Manipulation::BASE_64_DETECTION_REGEX)
+        end
+      end
     end
 
-    it "to file" do
-      output = File.read('spec/support/web-env.yml')
-      KY::Cli.new.env('spec/support/config.yml', 'spec/support/decoded.yml', tmpfile_path)
-      expect(File.read(tmpfile_path)).to eq(output)
+    describe "encodes secrets.yml when compiling from Procfile with image_tag" do
+      it "to directory" do
+        instance = KY::Cli.new
+        instance.options = {image_tag: fake_tag}
+        instance.compile('spec/support/Procfile', 'spec/support/config.yml', 'spec/support/decoded.yml', tmpdir)
+        expect(File.exists?("#{tmpdir}/global.secret.yml")).to be true
+        YAML.load(File.read("#{tmpdir}/global.secret.yml"))['data'].each do |_k, v|
+          expect(v).to match(KY::Manipulation::BASE_64_DETECTION_REGEX)
+        end
+      end
     end
-  end
 
-  describe "compiles Procfile and env secrets/configs into entire deployments" do
-    let(:tmpdir) { 'spec/support/tmpdir' }
-    it "to directory" do
-      KY::Cli.new.compile('spec/support/Procfile', 'spec/support/config.yml', 'spec/support/decoded.yml', tmpdir)
-      expect(File.exists?("#{tmpdir}/web.deployment.yml")).to be true
-      expect(File.exists?("#{tmpdir}/worker.deployment.yml")).to be true
-      expect(File.exists?("#{tmpdir}/jobs.deployment.yml")).to be true
-      `rm -r #{tmpdir}`
+    describe "uses image_tag when passed in as option" do
+      let(:tmpdir) { 'spec/support/tmp2dir' }
+      it "to directory" do
+        instance = KY::Cli.new
+        instance.options = {image_tag: fake_tag}
+        instance.compile('spec/support/Procfile', 'spec/support/config.yml', 'spec/support/decoded.yml', tmpdir)
+        expect(File.exists?("#{tmpdir}/web.deployment.yml")).to be true
+        expect(File.read("#{tmpdir}/web.deployment.yml")).to match(fake_tag)
+      end
     end
-  end
 
+  end
 end
 

data/spec/support/web-env.yml

@@ -5,20 +5,11 @@ spec:
       containers:
       - env:
         - name: TZ
-          valueFrom:
-            configMapKeyRef:
-              name: test
-              key: tz
+          value: EST
         - name: REST_API_ID
-          valueFrom:
-            configMapKeyRef:
-              name: test
-              key: rest-api-id
+          value: 1234abcd
         - name: USE_SSL
-          valueFrom:
-            configMapKeyRef:
-              name: test
-              key: use-ssl
+          value: true
         - name: DATABASE_URL
           valueFrom:
             secretKeyRef:

data/spec/support/web-merged.yml

@@ -23,20 +23,11 @@ spec:
         - bundle exec rake assets:precompile && bundle exec puma -C ./config/puma.rb
         env:
         - name: TZ
-          valueFrom:
-            configMapKeyRef:
-              name: test
-              key: tz
+          value: EST
         - name: REST_API_ID
-          valueFrom:
-            configMapKeyRef:
-              name: test
-              key: rest-api-id
+          value: 1234abcd
         - name: USE_SSL
-          valueFrom:
-            configMapKeyRef:
-              name: test
-              key: use-ssl
+          value: true
         - name: DATABASE_URL
           valueFrom:
             secretKeyRef:

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ky
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.3
 platform: ruby
 authors:
 - Brian Glusman