etcenv 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c67fca7ce92b7e16d5365bdc969aa6e974fc6cc9
+  data.tar.gz: 99ad3db08fcc4e806a677cfe085bb475e1dceab7
+SHA512:
+  metadata.gz: 3c1e239945d4bbbd0735f3f8ec451eab0da1ca607cdbfd9390543b10aec9718364ec51081fa521343d9d05607b55357fc73b8a2f2ff45a22f83d568edb26ea22
+  data.tar.gz: d5b380c6fa77885aa7d0d1d522b185184fa959a9f6864018b01696061451aeea356b47f84a09e9adf9ae93f1e0f2b848928016c8e2415cb6b322a5d67fef7479

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.2.0

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in etcenv.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Shota Fukumori (sora_h)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,104 @@
+# Etcenv: Dump etcd keys into dotenv file or docker env file
+
+## Installation
+
+    $ gem install etcenv
+
+## Simple Usage
+
+### Create directory and keys on etcd
+
+```
+etcdctl mkdir /my-app
+etcdctl set /my-app/AWESOME_SERVICE_CREDENTIAL xxxxxx
+```
+
+### Run `etcenv`
+
+#### One-shot
+
+This will output generated .env file to STDOUT.
+
+```
+$ etcenv /my-app
+AWESOME_SERVICE_CREDENTIAL=xxxxxx
+```
+
+or
+
+```
+$ etcenv -o .env /my-app
+$ cat .env
+AWESOME_SERVICE_CREDENTIAL=xxxxxx
+```
+
+to save as file.
+
+#### Continuously update
+
+Etcenv also supports watching etcd server. In `--watch` mode, Etcenv updates dotenv file when value gets updated:
+
+```
+$ etcenv --watch -o .env /my-env
+```
+
+Also you can start it as daemon:
+
+```
+$ etcenv --watch --daemon /path/to/pidfile.pid -o .env /my-env
+```
+
+#### For docker
+
+Use `--docker` flag to generate file for docker's `--env-file` option.
+
+In docker mode, etcenv evaluates `${...}` expansion like dotenv do.
+
+## Options
+
+### etcd options
+
+- `--etcd`: URL of etcd to connect to. Path in URL will be ignored.
+- `--etcd-ca-file`: Path to CA certificate file (PEM) of etcd server.
+- `--etcd-cert-file`: Path to client certificate file for etcd.
+- `--etcd-key-file`: Path to private key file of client certificate file for etcd.
+
+## Advanced usage
+
+### Include other directory's variables
+
+Set directory path to `_include`. Directories can be specified multiple, separated by comma.
+
+```
+etcdctl mkdir /common
+etcdctl set /common/COMMON_SECRET xxx
+etcdctl set /my-app/_include /common
+```
+
+Also, you can omit path of parent directory:
+
+```
+etcdctl mkdir /envs/common
+etcdctl set /envs/common/COMMON_SECRET xxx
+
+etcdctl mkdir /envs/my-app
+etcdctl set /envs/my-app/_include common
+```
+
+- `_include` will be applied recursively (up to 10 times by default). If `_include` is looping, it'll be an error.
+- For multiple `_include`, value for same key may be overwritten.
+  - If `a` includes `b`,`c` and `b` includes `d`, result for `a` will be: `d`, `b`, `c`, then `a`.
+
+## Development
+
+After checking out the repo, run `scripts/setup` to install dependencies. Then, run `scripts/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/sorah/etcenv/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/etcenv

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require 'etcenv'
+require 'etcenv/cli'
+
+exit Etcenv::Cli.new(*ARGV).run

data/etcenv.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'etcenv/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "etcenv"
+  spec.version       = Etcenv::VERSION
+  spec.authors       = ["Shota Fukumori (sora_h)"]
+  spec.email         = ["sorah@cookpad.com"]
+
+  spec.summary       = %q{Dump etcd keys into dotenv file or docker env file}
+  spec.homepage      = "https://github.com/sorah/etcenv"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "bin"
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+
+  spec.add_dependency "etcd", ">= 0.3.0"
+end

data/lib/etcenv/cli.rb

@@ -0,0 +1,170 @@
+require 'optparse'
+require 'thread'
+require 'openssl'
+require 'etcd'
+require 'uri'
+require 'etcenv/dockerenv_file'
+require 'etcenv/dotenv_file'
+require 'etcenv/watcher'
+
+module Etcenv
+  class Cli
+    def initialize(*argv)
+      @argv = argv
+      @options = {
+        etcd: URI.parse("http://localhost:2379"),
+        format: DotenvFile,
+        perm: 0600,
+        mode: :oneshot,
+      }
+      parse!
+    end
+
+    attr_reader :argv, :options
+
+    def run
+      parse!
+
+      case options[:mode]
+      when :oneshot
+        oneshot
+      when :watch
+        watch
+      else
+        raise "[BUG] unknown mode"
+      end
+    end
+
+    def parse!
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: etcenv [options] key ..."
+
+        opts.on("-h", "--help", "show this help") do
+          puts opts
+          exit 0
+        end
+
+        opts.on("--watch", "-w", "continuous update mode") do
+          options[:mode] = :watch
+        end
+
+        opts.on("--daemon", "-d", "daemonize") do
+          options[:daemonize] = true
+        end
+
+        opts.on("--pidfile PIDFILE", "-p PIDFILE", "pidfile to use when deamonizing") do |pidpath|
+          options[:pidfile] = pidpath
+        end
+
+        opts.on("-o PATH", "--output PATH", "save to speciifed file") do |path|
+          options[:output] = path
+        end
+
+        opts.on("-m MODE", "--mode MODE", "mode (permission) to use when creating --output file, in octal. Default: 0600") do |perm|
+          options[:perm] = perm.to_i(8)
+        end
+
+        opts.on("--docker", "use docker env-file format instead of dotenv.gem format") do
+          options[:format] = DockerenvFile
+        end
+
+        opts.on("--etcd URL", "URL of etcd to connect; Any paths are ignored.") do |url|
+          options[:etcd] = URI.parse(url)
+        end
+
+        opts.on("--etcd-ca-file PATH", "Path to CA certificate file (PEM) of etcd server") do |path|
+          options[:etcd_ca_file] = path
+        end
+
+        opts.on("--etcd-cert-file PATH", "Path to client certificate file (PEM) for etcd server") do |path|
+          options[:etcd_tls_cert] = OpenSSL::X509::Certificate.new(File.read(path))
+        end
+
+        opts.on("--etcd-key-file PATH", "Path to private key file for client certificate for etcd server") do |path|
+          options[:etcd_tls_key] = OpenSSL::PKey::RSA.new(File.read(path))
+        end
+      end
+      parser.parse!(argv)
+    end
+
+    def etcd
+      @etcd ||= Etcd.client(
+        host: options[:etcd].host,
+        port: options[:etcd].port,
+        use_ssl: options[:etcd].scheme == 'https',
+        ca_file: options[:etcd_ca_file],
+        ssl_cert: options[:etcd_tls_cert],
+        ssl_key: options[:etcd_tls_key],
+      )
+    end
+
+    def oneshot
+      if argv.empty?
+        $stderr.puts "error: no KEY specified. See --help for detail"
+        return 1
+      end
+      env = argv.inject(nil) do |env, key|
+        new_env = Environment.new(etcd, key).env
+        env ? env.merge(new_env) : new_env
+      end
+      dump_env(env)
+
+      0
+    end
+
+    def watch
+      if argv.empty?
+        $stderr.puts "error: no KEY specified. See --help for detail"
+        return 1
+      end
+
+      if options[:daemonize]
+        $stderr.puts "Daemonizing"
+        Process.daemon(nil, true)
+        if options[:pidfile]
+          File.write options[:pidfile], "#{$$}\n"
+        end
+      end
+
+      envs = argv.map { |key| Environment.new(etcd, key) }
+
+      watchers = envs.map { |env| Watcher.new(env, verbose: true) }
+      Thread.abort_on_exception = true
+
+      dumper_ch = Queue.new
+      dumper = Thread.new do
+        loop do
+          $stderr.puts "[dumper] dumping env"
+          env = envs.inject(nil) do |result, env|
+            result ? result.merge(env.env) : env.env
+          end
+          dump_env(env)
+          dumper_ch.pop
+        end
+      end
+
+      watchers.map do |watcher|
+        Thread.new do
+          watcher.auto_reload_loop do
+            dumper_ch << true
+          end
+        end
+      end
+
+      loop { sleep 1 }
+    end
+
+    private
+
+    def dump_env(env)
+      env_file = options[:format].new(env)
+      if options[:output]
+        open(options[:output], "w", options[:perm]) do |io|
+          io.puts env_file.to_s
+        end
+      else
+        $stdout.puts env_file.to_s
+      end
+    end
+  end
+end

data/lib/etcenv/dockerenv_file.rb

@@ -0,0 +1,25 @@
+require 'etcenv/variable_expander'
+
+module Etcenv
+  class DockerenvFile
+    def initialize(env)
+      @env = env
+    end
+
+    attr_reader :env
+
+    def expanded_env
+      VariableExpander.expand @env
+    end
+
+    def lines
+      expanded_env.map { |k,v| "#{k}=#{v}" }
+    end
+
+    def to_s
+      lines.join(?\n) + ?\n
+    end
+
+    private
+  end
+end

data/lib/etcenv/dotenv_file.rb

@@ -0,0 +1,37 @@
+require 'etcenv/variable_expander'
+
+module Etcenv
+  class DotenvFile
+    def initialize(env)
+      @env = env
+    end
+
+    attr_reader :env
+
+    def expanded_env
+      VariableExpander.expand @env
+    end
+
+    def lines
+      expanded_env.map { |k, v| make_dotenv_line(k, v) }
+    end
+
+    def to_s
+      lines.join(?\n) + ?\n
+    end
+
+    private
+
+    SHOULD_QUOTE = /\n|"|#|\$/
+    def make_dotenv_line(k,v)
+      if v.match(SHOULD_QUOTE)
+        v.gsub!('"', '\"')
+        v.gsub!("\n", '\n')
+        v.gsub!(/\$([^(])/, '\$\1')
+        "#{k}=\"#{v}\""
+      else
+        "#{k}=#{v}"
+      end
+    end
+  end
+end

data/lib/etcenv/environment.rb

@@ -0,0 +1,116 @@
+module Etcenv
+  class Environment
+    class NotDirectory < StandardError; end
+    class DepthLimitError < StandardError; end
+    class LoopError < StandardError; end
+
+    INCLUDE_KEY = '_include'
+    MAX_DEPTH_DEFAULT = 10
+
+    def initialize(etcd, root_key, max_depth: MAX_DEPTH_DEFAULT)
+      @etcd = etcd
+      @root_key = root_key
+      @max_depth = max_depth
+      @lock = Mutex.new
+      load
+    end
+    
+    attr_reader :root_key, :env, :etcd
+    attr_accessor :max_depth
+
+    def modified_indices
+      @modified_indices ||= {}
+    end
+
+    def load
+      @lock.synchronize do
+        flush
+        env = {}
+        includes.each do |name|
+          env.merge! fetch(name)
+        end
+        env.delete '_include'
+        @env = env
+      end
+      self
+    end
+
+    private
+
+    def flush
+      @env = {}
+      @includes = nil
+      @cache = {}
+      @modified_indices = {}
+      self
+    end
+
+    def includes
+      @includes ||= solve_include_order(root_key)
+    end
+
+    def default_prefix
+      root_key.sub(/^.*\//, '')
+    end
+
+    def resolve_key(key)
+      if key.start_with?('/')
+        key
+      else
+        default_prefix + '/' + key
+      end
+    end
+
+    def cache
+      @cache ||= {}
+    end
+
+    def fetch(name)
+      key = resolve_key(name)
+      return cache[key] if cache[key]
+
+      node = @etcd.get(key).node
+
+      unless node.dir
+        raise NotDirectory, "#{key} is not a directory"
+      end
+
+      dir = {}
+      index = 0
+
+      node.children.each do |child|
+        name = child.key.sub(/^.*\//, '')
+        if child.dir
+          next
+        else
+          dir[name] = child.value
+          index = [index, child.modified_index].max
+        end
+      end
+
+      modified_indices[key] = index
+      cache[key] = dir
+    end
+
+    def solve_include_order(name, path = [])
+      if path.include?(name)
+        raise LoopError, "Found an include loop at path: #{path.inspect}"
+      end
+
+      path = path + [name]
+      if max_depth < path.size
+        raise DepthLimitError, "Reached maximum depth (path: #{path.inspect})"
+      end
+
+      node = fetch(name)
+
+      if node[INCLUDE_KEY]
+        node[INCLUDE_KEY].split(/,\s*/).flat_map do |x|
+          solve_include_order(x, path)
+        end + [name]
+      else
+        [name]
+      end
+    end
+  end
+end

data/lib/etcenv/utils.rb

@@ -0,0 +1,16 @@
+module Etcenv
+  module Utils
+    class << self
+      def uniq_with_keeping_first_appearance(array)
+        set = {}
+        result = []
+        array.each do |x|
+          next if set[x]
+          result.push x
+          set[x] = true
+        end
+        result
+      end
+    end
+  end
+end

data/lib/etcenv/variable_expander.rb

@@ -0,0 +1,122 @@
+require 'etcenv/utils'
+
+module Etcenv
+  class VariableExpander
+    class LoopError < StandardError; end
+    class DepthLimitError < StandardError; end
+
+    MAX_DEPTH_DEFAULT = 50
+
+    def self.expand(variables, max = MAX_DEPTH_DEFAULT)
+      new(variables).expand(max)
+    end
+
+    def initialize(variables)
+      @variables = variables.dup.freeze
+    end
+
+    attr_reader :variables
+
+    def expand(max = MAX_DEPTH_DEFAULT)
+      detect_loop!
+
+      result = {}
+      solve_order(max).map do |x|
+        result[x] = single_expand(@variables[x], result)
+      end
+      result
+    end
+
+    def variable_with_deps
+      @variables.map { |k, v| [k, [v, detect_variables(v)]] }
+    end
+
+    def dependees_by_variable
+      @dependees_by_variable ||= variable_with_deps.inject({}) do |r, x|
+        k, v, deps = x[0], x[1][0], x[1][1]
+
+        deps.each do |dep|
+          r[dep] ||= []
+          r[dep] << k
+        end
+        r
+      end.freeze
+    end
+
+    def root_variables
+      @root_variables ||= variable_with_deps.inject([]) do |r, x|
+        k, v, deps = x[0], x[1][0], x[1][1]
+        if deps.empty?
+          r << k
+        end
+        r
+      end + (variables.keys - dependees_by_variable.keys)
+    end
+
+    def detect_loop!
+      if root_variables.empty?
+        raise LoopError, "there's no possible root variables (variables which don't have dependee)"
+      else
+        dependees_by_variable.each do |k, deps|
+          deps.each do |dep|
+            if (dependees_by_variable[dep] || []).include?(k)
+              raise LoopError, "There's a loop between $#{dep} and $#{k}"
+            end
+          end
+        end
+      end
+    end
+
+    def solve_order(max_depth = 10)
+      order = []
+      solve = nil
+      solve = ->(vs, depth = 0) do
+        raise DepthLimitError if depth.succ > max_depth
+        vs.each do |x|
+          order.concat solve.call(dependees_by_variable[x] || [], depth.succ) + [x]
+        end
+      end
+      solve.call(root_variables)
+
+      Utils.uniq_with_keeping_first_appearance(order).reverse
+    end
+
+    private
+
+    VARIABLE = /
+      (?<escape>\\?)
+      \$
+      (
+        {(?<name>[a-zA-Z0-9_]+)}
+      |
+        \g<name>
+      )
+    /x
+
+    def detect_variables(str)
+      result = []
+
+      pos = 0
+      while match = str.match(VARIABLE, pos)
+        pos = match.end(0)
+        next if match['escape'] == '\\'
+
+        result << match['name']
+      end
+
+      result
+    end
+
+    def single_expand(str, variables)
+      str.gsub(VARIABLE) do |variable|
+        match = $~
+
+        if match['escape'] == '\\'
+          variable[1..-1]
+        else
+          variables[match['name']].to_s
+        end
+      end
+    end
+  end
+end

data/lib/etcenv/version.rb

@@ -0,0 +1,3 @@
+module Etcenv
+  VERSION = "0.1.0"
+end

data/lib/etcenv/watcher.rb

@@ -0,0 +1,40 @@
+require 'thread'
+
+module Etcenv
+  class Watcher
+    def initialize(env, verbose: false)
+      @env = env
+      @verbose = verbose
+    end
+
+    attr_reader :env, :verbose
+
+    def etcd
+      env.etcd
+    end
+
+    def watch
+      ch = Queue.new
+      threads = env.modified_indices.map do |key, index|
+        Thread.new do
+          $stderr.puts "[watcher] waiting for change on #{key} (index: #{index.succ})" if verbose
+          etcd.watch(key, recursive: true, index: index.succ)
+          $stderr.puts "[watcher] dir #{key} has updated" if verbose
+          ch << key
+        end
+      end
+      report = ch.pop
+      threads.each(&:kill)
+      report
+    end
+
+    def auto_reload_loop
+      loop do
+        watch
+        $stderr.puts "[watcher] reloading env #{env.root_key}" if verbose
+        env.load
+        yield env if block_given?
+      end
+    end
+  end
+end

data/lib/etcenv.rb

@@ -0,0 +1,5 @@
+require 'etcenv/version'
+require 'etcenv/environment'
+require 'etcenv/variable_expander'
+require 'etcenv/dockerenv_file'
+require 'etcenv/dotenv_file'

data/scripts/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "etcenv"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/scripts/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: etcenv
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Shota Fukumori (sora_h)
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: etcd
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+description: 
+email:
+- sorah@cookpad.com
+executables:
+- etcenv
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/etcenv
+- etcenv.gemspec
+- lib/etcenv.rb
+- lib/etcenv/cli.rb
+- lib/etcenv/dockerenv_file.rb
+- lib/etcenv/dotenv_file.rb
+- lib/etcenv/environment.rb
+- lib/etcenv/utils.rb
+- lib/etcenv/variable_expander.rb
+- lib/etcenv/version.rb
+- lib/etcenv/watcher.rb
+- scripts/console
+- scripts/setup
+homepage: https://github.com/sorah/etcenv
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Dump etcd keys into dotenv file or docker env file
+test_files: []