export_mongo_s3 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d3c8c2fbe8679bb4b3c17ea0ceed2c86492a00c6
+  data.tar.gz: 7e2192e16878e2cd87a4f6e4fa247ca081e60284
+SHA512:
+  metadata.gz: d9f0bf7dcbd0500bddfbc24c7e8ed89e0f3ba034a582a715da5145a999c61410a98ff58edc03adb18c43e6ad45a72918425097c898a362603d9164281138b774
+  data.tar.gz: 2fba509d5f4ba909c62437e95914586a6fa812f8ab92a497d71dbd4ef4d8a45da1df562b8e43c48e6f9f28b6b58a734f5ec7a5fa470cc5818a0297e4ddf37f83

data/.gitignore

@@ -0,0 +1,24 @@
+*.gem
+*.rbc
+*.idea
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+*.yml

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gem 'aws-sdk'

data/README.md

@@ -0,0 +1,20 @@
+# ExportMongoS3
+
+Command-line application for MongoDB export(mongoexport) to CSV and upload to Amazon S3
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'export_mongo_s3'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install export_mongo_s3
+
+## Help
+                                                    

data/bin/export_mongo_s3

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/export_mongo_s3'
+
+begin
+  ExportMongoS3::Application.new(ARGV).run
+rescue SystemExit
+  # do nothing
+rescue Exception => error
+  abort "[abort] #{error.message}"
+end

data/export_mongo_s3.gemspec

@@ -0,0 +1,19 @@
+Gem::Specification.new do |spec|
+  spec.name          = 'export_mongo_s3'
+  spec.version       = '0.0.1'
+  spec.authors       = ['Yakupov Dima']
+  spec.email         = ['yakupov.dima@mail.ru']
+  spec.summary       = "Some summary"
+  spec.description   = "Command-line application for MongoDB export(mongoexport) to CSV and upload to Amazon S3"
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+
+  spec.add_runtime_dependency 'aws-sdk', '~> 1.57'
+end

data/lib/export_mongo_s3.rb

@@ -0,0 +1,28 @@
+require 'optparse'
+require 'aws-sdk'
+require 'fileutils'
+require 'digest/md5'
+require 'tmpdir'
+
+require_relative 'export_mongo_s3/application'
+require_relative 'export_mongo_s3/db'
+require_relative 'export_mongo_s3/storage'
+require_relative 'export_mongo_s3/scheduler'
+
+require_relative 'helpers/fixnum'
+require_relative 'helpers/hash'
+require_relative 'helpers/time'
+
+module ExportMongoS3
+
+  def self.name
+    File.basename( __FILE__, '.rb')
+  end
+
+  def self.root_path
+    @root_path if @root_path
+    spec = Gem::Specification.find_by_name(self.name)
+    @root_path = spec.gem_dir
+  end
+end
+

data/lib/export_mongo_s3/application.rb

@@ -0,0 +1,226 @@
+module ExportMongoS3
+  class Application
+
+    def initialize(argv)
+      @parser = OptionParser.new
+
+      @params = parse_options(argv)
+      @config = parse_config(@params[:config])
+
+      db_options = @config[:mongo]
+      db_options.merge!(collections: @config[:export][:collections])
+
+      @db = Db.new(db_options)
+
+      @storage = Storage.new(@config[:s3])
+    end
+
+
+    public
+
+    def run
+
+      case
+        when @params[:export_list] # EXPORT_LIST
+          show_uploaded_files(@params[:export_list])
+
+        when @params[:export_all] # EXPORT_ALL
+          dbs_str = @config[:export][:dbs]
+
+          if dbs_str.nil? || dbs_str.empty?
+            raise 'config.yml::export.dbs is empty'
+          end
+
+          db_names = dbs_str.split(',').each { |db_name| db_name.strip! }
+
+          export(db_names)
+
+        when @params[:export] # EXPORT
+          export([@params[:export]])
+
+        when @params[:cron_update] || @params[:cron_clear] # CRON
+          cron_options =
+              {
+                  update: @params[:cron_update],
+                  clear:  @params[:cron_clear],
+                  config: @params[:config],
+                  time:   @config[:backup][:cron_time],
+              }
+
+          Scheduler.new(cron_options).execute
+
+        else
+          puts "\n#{@parser}\n"
+          exit(0)
+      end
+
+    end
+
+
+    private
+
+    def show_uploaded_files(db_name)
+
+      files = @storage.get_uploaded_files(db_name)
+
+      if files.empty?
+        puts 'Files not found'
+      else
+
+        puts sprintf('%-30s %-15s %-20s', 'name', 'size, MB', 'last_modified')
+
+        files.each do |file|
+
+          file_name          = file.key
+          file_size          = file.content_length / 1024 / 1024
+          file_last_modified = file.last_modified
+
+          puts sprintf('%-30s %-15s %-20s', file_name, file_size, file_last_modified)
+        end
+
+      end
+    end
+
+    def export(db_names)
+
+      db_names.each do |db_name|
+
+        puts "export db #{db_name.upcase}:"
+
+        tmp_dir = get_temp_dir
+
+        begin
+
+          export_path = File.join(tmp_dir, db_name)
+
+          puts "\t make csv..."
+          @db.export_db(db_name, export_path)
+
+          if Dir["#{export_path}/*"].empty?
+            puts "\t [skip] db is empty"
+
+          else
+
+            puts "\t compress..."
+            zip_result = %x(zip -6 -r '#{export_path}.zip' '#{export_path}/' -j)
+            raise "Error zip. Msg: #{zip_result}" unless $?.exitstatus.zero?
+
+            FileUtils.rm_rf(export_path)
+
+            zip_file_path = "#{export_path}.zip"
+
+            if File.exists?(zip_file_path)
+              puts "\t upload to s3..."
+              @storage.upload(db_name, zip_file_path)
+
+              File.delete(zip_file_path)
+            end
+
+          end
+
+        ensure
+          FileUtils.remove_entry_secure(tmp_dir)
+        end
+
+      end
+
+      puts '[done] export'
+    end
+
+    def create_config(path)
+
+      path = '.' if path.nil? || path == ''
+
+      file = File.join(path, 'config.yml')
+
+      if File.exists?(file)
+        raise "create_config: '#{file}' already exists"
+      elsif File.exists?(file.downcase)
+        raise "create_config: '#{file.downcase}' exists, which could conflict with '#{file}'"
+      elsif !File.exists?(File.dirname(file))
+        raise "create_config: directory '#{File.dirname(file)}' does not exist"
+      else
+        file_template = File.join(ExportMongoS3.root_path, 'lib/helpers/config.yml.template')
+
+        FileUtils.cp file_template, file
+      end
+
+      puts "[done] file #{file} was created"
+    end
+
+    def parse_options(argv)
+      params = {}
+
+      @parser.on('--export_all', 'Export databases specified in config.yml and upload to S3 bucket') do
+        params[:export_all] = true
+      end
+      @parser.on('--export DB_NAME', String, 'Export database and upload to S3 bucket') do |db_name|
+        params[:export] = db_name
+      end
+      @parser.on('-l', '--list_exported [DB_NAME]', String, 'Show list of exported dbs') do |db_name|
+        params[:export_list] = db_name || ''
+      end
+      @parser.on('--write_cron', 'Add/update export_all job') do
+        params[:cron_update] = true
+      end
+      @parser.on('--clear_cron', 'Clear export_all job') do
+        params[:cron_clear] = true
+      end
+      @parser.on('-c', '--config PATH', String, 'Path to config *.yml. Default: ./config.yml') do |path|
+        params[:config] = path || ''
+      end
+      @parser.on('--create_config [PATH]', String, 'Create template config.yml in current/PATH directory') do |path|
+        create_config(path)
+        exit(0)
+      end
+      @parser.on('-h', '--help', 'Show help') do
+        puts "\n#{@parser}\n"
+        exit(0)
+      end
+
+      @parser.parse!(argv)
+
+      if [params[:export_all], params[:export], params[:export_list], params[:cron_update], params[:cron_clear]].compact.length > 1
+        raise 'Can only export_all, export, list_exported, write_cron or clear_cron. Choose one.'
+      end
+
+      if params[:config].nil? || params[:config] == ''
+        params[:config] = './config.yml'
+      end
+
+      params[:config] = File.absolute_path(params[:config])
+
+      params
+    end
+
+    def parse_config(config_path)
+
+      begin
+        config = YAML.load(File.read(config_path))
+      rescue Errno::ENOENT
+        raise "Could not find config file '#{config_path}'"
+      rescue ArgumentError => error
+        raise "Could not parse config file '#{config_path}' - #{error}"
+      end
+
+      config.deep_symbolize_keys!
+
+      raise 'config.yml. Section <export> not found' if config[:export].nil?
+      raise 'config.yml. Section <mongo> not found' if config[:mongo].nil?
+      raise 'config.yml. Section <s3> not found' if config[:s3].nil?
+
+      config
+    end
+
+    def get_temp_dir
+      temp_dir = @config[:export][:temp_directory]
+
+      if temp_dir.nil? || temp_dir == ''
+        temp_dir = Dir.tmpdir
+      end
+
+      Dir.mktmpdir(nil, temp_dir)
+    end
+
+  end
+end

data/lib/export_mongo_s3/db.rb

@@ -0,0 +1,142 @@
+module ExportMongoS3
+  class Db
+
+    SYSTEM_COLLECTIONS = %w(admin_users fs.chunks fs.files system.indexes)
+
+    def initialize(options)
+      @options            = options
+      @connection_options = connection(options)
+    end
+
+
+    public
+
+    def export_db(db, out_path)
+
+      collection_settings_map = prepared_collection_settings
+
+      if collection_settings_map.empty?
+        collection_names = get_collections(db)
+      else
+        collection_names = collection_settings_map.keys
+      end
+
+      collection_names.each do |collection_name|
+
+        collection_settings = collection_settings_map[collection_name]
+
+        if collection_settings.nil?
+          export(db, collection_name, out_path)
+        else
+          fields = collection_settings[:fields]
+          query  = collection_settings[:query]
+
+          export(db, collection_name, out_path, fields, query)
+        end
+      end
+
+    end
+
+    private
+
+    def connection(options)
+      host                    = (options[:host].nil? || options[:host] == '') ? 'localhost' : options[:host]
+      port                    = options[:port].nil? ? 27017 : options[:port]
+      username                = options[:username]
+      password                = options[:password]
+      authentication_database = options[:authentication_database]
+
+      auth_options = ''
+
+      unless username.nil? || username == '' || password.nil? || password == ''
+        auth_options = "-u '#{username}' -p '#{password}'"
+        auth_options << " --authenticationDatabase '#{authentication_database}'" unless authentication_database.nil? || authentication_database == ''
+      end
+
+      "--host '#{host}' --port '#{port}' #{auth_options}"
+    end
+
+    def export(db, collection, out_path, fields = [], query = nil)
+
+      if fields.empty?
+        fields = get_fields(db, collection)
+      end
+
+      return if fields.empty?
+
+      command = 'mongoexport'
+      command << " #{@connection_options}"
+      command << ' --csv'
+      command << " --db '#{db}'"
+      command << " --collection '#{collection}'"
+      command << " --fields '#{fields.join(',')}'"
+      command << " --query '#{query}'" unless query.nil?
+      command << " --out '#{out_path}/#{collection}.csv'"
+      command << ' > /dev/null'
+
+      system(command)
+      raise "Error mongoexport '#{db}'" unless $?.exitstatus.zero?
+    end
+
+    def get_collections(db)
+      command = 'mongo'
+      command << " #{@connection_options}"
+      command << " #{db} --eval 'rs.slaveOk(); db.getCollectionNames();'"
+      command << ' --quiet'
+
+      result = %x(#{command})
+      raise "Error get collections for db '#{db}'. Msg: #{result}" unless $?.exitstatus.zero?
+
+      result.strip.split(',') - SYSTEM_COLLECTIONS
+    end
+
+    def get_fields(db, collection)
+      command = 'mongo'
+      command << " #{@connection_options}"
+      command << " #{db} --eval 'rs.slaveOk(); var fields = []; for(var field in db.#{collection}.find().sort({_id: -1}).limit(1)[0]) { fields.push(field); }; fields;'"
+      command << ' --quiet'
+
+      result = %x(#{command})
+      raise "Error get fields for db '#{db}' and collection '#{collection}'. Msg: #{result}" unless $?.exitstatus.zero?
+
+      result.strip.split(',')
+    end
+
+    def prepared_collection_settings
+      @prepared_collection_settings if @prepared_collection_settings
+
+      collection_settings = @options[:collections]
+
+      prepared_settings = {}
+
+      if collection_settings.is_a?(Array)
+        collection_settings.each do |collection|
+
+          name  = collection['name']
+          query = collection['query'].nil? || collection['query'] == '' ? nil : collection['query'].to_s
+
+          fields = if collection['fields'].is_a?(String)
+                     collection['fields'].split(',').each { |field| field.strip! }
+                   else
+                     []
+                   end
+
+
+          if name.nil? || name == ''
+            raise "Not valid param <name: #{collection}>"
+          end
+
+          prepared_settings[name] =
+              {
+                  name:   name,
+                  fields: fields,
+                  query:  query
+              }
+        end
+      end
+
+      @prepared_collection_settings = prepared_settings
+    end
+
+  end
+end

data/lib/export_mongo_s3/scheduler.rb

@@ -0,0 +1,97 @@
+module ExportMongoS3
+  class Scheduler
+
+    def initialize(options = {})
+      @options = options
+
+      if [@options[:write], @options[:clear]].compact.length > 1
+        raise 'cron: Can only write or clear. Choose one.'
+      end
+
+      unless @options[:time] =~ /\A[*\-,0-9]+ [*\-,0-9]+ [*\-,0-9]+ [*\-,0-9]+ [*\-,0-6]+\z/
+        raise 'config.yml: cron_time is not valid'
+      end
+    end
+
+    def execute
+      write_crontab(updated_crontab)
+    end
+
+    private
+
+    def read_crontab
+      return @read_crontab if @read_crontab
+
+      command = 'crontab -l'
+
+      command_results = %x[#{command} 2> /dev/null]
+
+      @read_crontab = $?.exitstatus.zero? ? prepare(command_results) : ''
+    end
+
+    def prepare(contents)
+      # Some cron implementations require all non-comment lines to be newline-
+      # terminated. (issue #95) Strip all newlines and replace with the default
+      # platform record seperator ($/)
+      contents.gsub!(/\s+$/, $/)
+    end
+
+    def write_crontab(contents)
+      command = 'crontab -'
+
+      IO.popen(command, 'r+') do |crontab|
+        crontab.write(contents)
+        crontab.close_write
+      end
+
+      success = $?.exitstatus.zero?
+
+      if success
+        action = @options[:update] ? 'updated' : 'cleared'
+        puts "[done] crontab file #{action}"
+        exit(0)
+      else
+        raise "Couldn't write crontab"
+      end
+    end
+
+    def updated_crontab
+      # Check for unopened or unclosed identifier blocks
+      if read_crontab =~ Regexp.new("^#{comment_open}\s*$") && (read_crontab =~ Regexp.new("^#{comment_close}\s*$")).nil?
+        raise "Unclosed indentifier; Your crontab file contains '#{comment_open}', but no '#{comment_close}'"
+      elsif (read_crontab =~ Regexp.new("^#{comment_open}\s*$")).nil? && read_crontab =~ Regexp.new("^#{comment_close}\s*$")
+        raise "Unopened indentifier; Your crontab file contains '#{comment_close}', but no '#{comment_open}'"
+      end
+
+      # If an existing identier block is found, replace it with the new cron entries
+      if read_crontab =~ Regexp.new("^#{comment_open}\s*$") && read_crontab =~ Regexp.new("^#{comment_close}\s*$")
+        # If the existing crontab file contains backslashes they get lost going through gsub.
+        # .gsub('\\', '\\\\\\') preserves them. Go figure.
+        read_crontab.gsub(Regexp.new("^#{comment_open}\s*$.+^#{comment_close}\s*$", Regexp::MULTILINE), crontab_task.chomp.gsub('\\', '\\\\\\'))
+      else # Otherwise, append the new cron entries after any existing ones
+        [read_crontab, crontab_task].join("\n\n")
+      end.gsub(/\n{3,}/, "\n\n") # More than two newlines becomes just two.
+    end
+
+    def crontab_task
+      return '' if @options[:clear]
+      [comment_open, crontab_job, comment_close].compact.join("\n") + "\n"
+    end
+
+    def crontab_job
+      "#{@options[:time]} /bin/bash -l -c '#{ExportMongoS3.name} --export_all --config #{@options[:config]}'"
+    end
+
+    def comment_base
+      "#{ExportMongoS3.name} task"
+    end
+
+    def comment_open
+      "# Begin #{comment_base}"
+    end
+
+    def comment_close
+      "# End #{comment_base}"
+    end
+  end
+end

data/lib/export_mongo_s3/storage.rb

@@ -0,0 +1,76 @@
+module ExportMongoS3
+  class Storage
+
+    def initialize(options)
+      @s3           = AWS::S3.new({access_key_id: options[:access_key_id], secret_access_key: options[:secret_access_key]})
+      @bucket       = get_bucket(options[:bucket])
+      @store_prefix = options[:store_prefix] || ''
+    end
+
+
+    public
+
+    def upload(store_path, file_name)
+      key = File.join(get_full_store_path(store_path), File.basename(file_name))
+
+      checksum = get_signature(file_name)
+
+      begin
+
+        file = File.open(file_name, 'rb')
+
+        obj = @bucket.objects[key]
+
+        obj.write(:content_length => file.size, metadata: {checksum: checksum}) do |buffer, bytes|
+          buffer.write(file.read(bytes))
+        end
+
+        file.close
+
+      rescue Exception => error
+        raise "Error upload file <#{file_name}> to s3 <#{key}>: #{error.message}"
+      end
+
+    end
+
+    def get_uploaded_files(prefix = '', limit = 100)
+      result = []
+
+      prefix = get_full_store_path(prefix)
+
+      @bucket.objects.with_prefix(prefix).each(:limit => limit) do |object|
+        unless object.key.end_with?('/')
+          result << object
+        end
+      end
+
+      result
+    end
+
+
+    private
+
+    def get_bucket(bucket_name)
+      bucket = @s3.buckets[bucket_name]
+
+      unless bucket.exists?
+        raise "Bucket #{bucket_name} doesn't not exists. Please create it"
+      end
+
+      bucket
+    end
+
+    def get_signature(file_name)
+      Digest::MD5.hexdigest(File.size(file_name).to_s)
+    end
+
+    def get_full_store_path(path)
+      if @store_prefix.empty?
+        path
+      else
+        File.join(@store_prefix, path)
+      end
+    end
+
+  end
+end

data/lib/helpers/config.yml.template

@@ -0,0 +1,36 @@
+export:
+  # List dbs for export
+  dbs: db1, db2
+
+  # List collections for export to csv.
+  # Format: array of name, [query], [fields].
+  # if collections empty than all collections with all fields will be export
+  collections:
+     - name: coll1
+
+     - name: coll2
+       query: '{field1: { $gte: 3 }, field2: 'value1'}'
+       fields: field1, field2, field3
+
+
+  # Temporary directory for files. Default: system temp directory
+  temp_directory:
+
+  # [minute] [hour] [day] [month] [weekday]
+  cron_time: 30 0 * * *
+
+mongo:
+  host: 'localhost'
+  port: 27017
+  username:
+  password:
+
+  # If you do not specify an authentication database than database specified to export holds the user’s credentials
+  authentication_database: admin
+
+
+s3:
+  access_key_id: 'access_key_id'
+  secret_access_key: 'secret_access_key'
+  bucket: 'export_mongo_s3-backups'
+  store_prefix:

data/lib/helpers/fixnum.rb

@@ -0,0 +1,11 @@
+class Fixnum
+  SECONDS_IN_DAY = 24 * 60 * 60
+
+  def days
+    self * SECONDS_IN_DAY
+  end
+
+  def ago
+    Time.now - self
+  end
+end

data/lib/helpers/hash.rb

@@ -0,0 +1,26 @@
+class Hash
+
+  def symbolize_keys!
+    transform_keys! { |key| key.to_sym rescue key }
+  end
+
+  def deep_symbolize_keys!
+    deep_transform_keys!{ |key| key.to_sym rescue key }
+  end
+
+  def transform_keys!
+    keys.each do |key|
+      self[yield(key)] = delete(key)
+    end
+    self
+  end
+
+  def deep_transform_keys!(&block)
+    keys.each do |key|
+      value = delete(key)
+      self[yield(key)] = value.is_a?(Hash) ? value.deep_transform_keys!(&block) : value
+    end
+    self
+  end
+
+end

data/lib/helpers/time.rb

@@ -0,0 +1,25 @@
+class Time
+
+  def midnight
+    change(:hour => 0)
+  end
+
+  def change(options)
+    new_year  = options.fetch(:year, year)
+    new_month = options.fetch(:month, month)
+    new_day   = options.fetch(:day, day)
+    new_hour  = options.fetch(:hour, hour)
+    new_min   = options.fetch(:min, options[:hour] ? 0 : min)
+    new_sec   = options.fetch(:sec, (options[:hour] || options[:min]) ? 0 : sec)
+    new_usec  = options.fetch(:usec, (options[:hour] || options[:min] || options[:sec]) ? 0 : Rational(nsec, 1000))
+
+    if utc?
+      ::Time.utc(new_year, new_month, new_day, new_hour, new_min, new_sec, new_usec)
+    elsif zone
+      ::Time.local(new_year, new_month, new_day, new_hour, new_min, new_sec, new_usec)
+    else
+      ::Time.new(new_year, new_month, new_day, new_hour, new_min, new_sec + (new_usec.to_r / 1000000), utc_offset)
+    end
+  end
+
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: export_mongo_s3
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Yakupov Dima
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.57'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.57'
+description: Command-line application for MongoDB export(mongoexport) to CSV and upload
+  to Amazon S3
+email:
+- yakupov.dima@mail.ru
+executables:
+- export_mongo_s3
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- bin/export_mongo_s3
+- export_mongo_s3.gemspec
+- lib/export_mongo_s3.rb
+- lib/export_mongo_s3/application.rb
+- lib/export_mongo_s3/db.rb
+- lib/export_mongo_s3/scheduler.rb
+- lib/export_mongo_s3/storage.rb
+- lib/helpers/config.yml.template
+- lib/helpers/fixnum.rb
+- lib/helpers/hash.rb
+- lib/helpers/time.rb
+homepage: ''
+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.4.2
+signing_key: 
+specification_version: 4
+summary: Some summary
+test_files: []