vagrant-compose 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 03a7541ea3a7eab57a665a0d510467c444c1683b
+  data.tar.gz: c78fe102cb943bf9f724379a762a6e268c471bda
+SHA512:
+  metadata.gz: 67e92a734dc62de90c13123df626f02830f5a328f6f7619708ef891ade36b4f890ec2f827ade85dbdf1ed91cce89bd51713d4403e038424ee8a3e78534f12e8c
+  data.tar.gz: 0640c723ad84731e00651c5f50ebad963e7fec8931057e12b0ae2542c334099300f97c33d079ae802d38068d94f8e469b5844d09c0ac3dedb64099c17efe09fa

data/.gitignore

@@ -0,0 +1,19 @@
+# OS-specific
+.DS_Store
+
+# editors
+*.swp
+
+# Bundler/Rubygems
+*.gem
+.bundle
+pkg/*
+tags
+Gemfile.lock
+
+# Vagrant
+.vagrant
+Vagrantfile
+
+# Test
+provisioning

data/.rspec

@@ -0,0 +1 @@
+--format doc --order random --color --fail-fast

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.0.0
+before_install: gem install bundler -v 1.10.5

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+# 0.1.0 (December 27, 2015)
+
+* Initial release.

data/Gemfile

@@ -0,0 +1,15 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in vagrant-compose.gemspec
+gemspec
+
+group :development do
+  # We depend on Vagrant for development, but we don't add it as a
+  # gem dependency because we expect to be installed within the
+  # Vagrant environment itself using `vagrant plugin`.
+  gem "vagrant", :git => "https://github.com/mitchellh/vagrant.git"
+end
+
+group :plugins do
+  gem "vagrant-compose" , path: "."
+end

data/LICENCE

@@ -0,0 +1,8 @@
+The MIT License (MIT)
+Copyright (c) 2015 Fabrizio Pandini
+
+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,3 @@
+# vagrant-compose
+A Vagrant plugin that helps building complex multi-machine scenarios
+

data/Rakefile

@@ -0,0 +1,23 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'rspec/core/rake_task'
+
+# Immediately sync all stdout so that tools like buildbot can
+# immediately load in the output.
+$stdout.sync = true
+$stderr.sync = true
+
+# Change to the directory of this file.
+Dir.chdir(File.expand_path("../", __FILE__))
+
+# This installs the tasks that help with gem creation and
+# publishing.
+Bundler::GemHelper.install_tasks
+
+# Install the `spec` task so that we can run tests.
+RSpec::Core::RakeTask.new
+
+# Default task is to run the unit tests
+task :default => "spec"
+
+print "zzz"

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "vagrant/compose"
+
+# 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/bin/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

data/lib/locales/en.yml

@@ -0,0 +1,37 @@
+en:
+  vagrant_compose:
+    already_status: |-
+      The machine is already %{status}.
+    errors:
+      initialize_error: |-
+        Error executing initialize code for cluster => %{cluster_name}.
+        The error message is shown below:
+        %{message}
+
+      attribute_expression_error: |-
+        Error generating attribute => %{attribute} for node => %{node_index} in group  => %{node_group_name}.
+        The error message is shown below:
+        %{message}
+
+        Attribute expression expected to be a literal or a code block returning a literal (see documentation).
+
+      context_var_expression_error: |-
+        Error generating ansible context vars for ansible_group => %{ansible_group} 
+        The error message is shown below:
+        %{message}
+
+        Ansible context var expression expected to be a Hash literal or a code block returning an Hash literal (see documentation).
+
+      group_var_expression_error: |-
+        Error generating ansible group vars for ansible_group => %{ansible_group} 
+        The error message is shown below:
+        %{message}
+
+        Ansible group var expression expected to be a Hash literal or a code block returning an Hash literal (see documentation).
+
+      host_var_expression_error: |-
+        Error generating ansible host vars for host => %{host} in ansible_group => %{ansible_group} 
+        The error message is shown below:
+        %{message}
+
+        Ansible host var expression expected to be a Hash literal or a code block returning an Hash literal (see documentation).

data/lib/vagrant/compose.rb

@@ -0,0 +1,18 @@
+require "pathname"
+
+require "vagrant/compose/plugin"
+
+module VagrantPlugins
+  module Compose
+    lib_path = Pathname.new(File.expand_path("../compose", __FILE__))
+
+    autoload :Errors, lib_path.join("errors")
+
+    # This returns the path to the source of this plugin.
+    #
+    # @return [Pathname]
+    def self.source_root
+      @source_root ||= Pathname.new(File.expand_path("../../", __FILE__))
+    end
+  end
+end

data/lib/vagrant/compose/config.rb

@@ -0,0 +1,38 @@
+require "vagrant"
+
+require_relative "util/cluster"
+
+module VagrantPlugins
+  module Compose
+    class Config < Vagrant.plugin("2", :config)
+
+      attr_reader :nodes, :ansible_groups
+
+	  def initialize
+		@nodes = {}
+		@ansible_groups = {}
+	  end
+	  
+	  def compose (name, &block)
+	    # implementa la creazione di un cluster, l'esecuzione di un blocco di codice
+  		# per la configurazione del cluster stesso, e l'esecuzione della sequenza di compose.
+		@cluster = Cluster.new(name)
+		begin
+        	block.call(@cluster)
+		rescue Exception => e
+	      raise VagrantPlugins::Compose::Errors::ClusterInitializeError, :message => e.message, :cluster_name => name
+	    end
+		@nodes, @ansible_groups = @cluster.compose
+ 	  end
+
+ 	  def debug
+ 	  	puts "==> cluster #{@cluster.name} with #{nodes.size} nodes" 
+ 	  	@nodes.each do |node|
+		   puts "        #{node.boxname} accessible as #{node.fqdn} #{node.aliases} #{node.ip} => [#{node.box}, #{node.cpus} cpus, #{node.memory} memory]"       
+
+ 	  	end
+    	puts "    ansible_groups filtered by #{@cluster.multimachine_filter}" if not @cluster.multimachine_filter.empty?
+ 	  end
+    end
+  end
+end

data/lib/vagrant/compose/errors.rb

@@ -0,0 +1,31 @@
+require "vagrant"
+
+module VagrantPlugins
+  module Compose
+    module Errors
+      class VagrantComposeError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant_compose.errors")
+      end
+
+      class ClusterInitializeError < VagrantComposeError
+        error_key(:initialize_error)
+      end
+
+      class AttributeExpressionError < VagrantComposeError
+        error_key(:attribute_expression_error)
+      end
+
+      class ContextVarExpressionError < VagrantComposeError
+        error_key(:context_var_expression_error)
+      end
+
+      class GroupVarExpressionError < VagrantComposeError
+        error_key(:group_var_expression_error)
+      end
+
+      class HostVarExpressionError < VagrantComposeError
+        error_key(:host_var_expression_error)
+      end
+    end
+  end
+end

data/lib/vagrant/compose/plugin.rb

@@ -0,0 +1,67 @@
+begin
+  require "vagrant"
+rescue LoadError
+  raise "The Vagrant Compose plugin must be run within Vagrant."
+end
+
+# This is a sanity check to make sure no one is attempting to install
+# this into an early Vagrant version.
+if Vagrant::VERSION < "1.8.1"
+  raise "The Vagrant Compose plugin is only compatible with Vagrant 1.8.1+"
+end
+
+module VagrantPlugins
+  module Compose
+    class Plugin < Vagrant.plugin("2")
+      name "Compose"
+      description <<-DESC
+      This plugin installs ...
+      DESC
+
+      config "cluster" do
+        # Setup logging and i18n
+        setup_logging
+        setup_i18n
+
+        require_relative "config"
+        Config
+      end
+
+
+      # This initializes the internationalization strings.
+      def self.setup_i18n
+        I18n.load_path << File.expand_path("locales/en.yml", Compose.source_root)
+        I18n.reload!
+      end
+
+      # This sets up our log level to be whatever VAGRANT_LOG is.
+      def self.setup_logging
+        require "log4r"
+
+        level = nil
+        begin
+          level = Log4r.const_get(ENV["VAGRANT_LOG"].upcase)
+        rescue NameError
+          # This means that the logging constant wasn't found,
+          # which is fine. We just keep `level` as `nil`. But
+          # we tell the user.
+          level = nil
+        end
+
+        # Some constants, such as "true" resolve to booleans, so the
+        # above error checking doesn't catch it. This will check to make
+        # sure that the log level is an integer, as Log4r requires.
+        level = nil if !level.is_a?(Integer)
+
+        # Set the logging level on all "vagrant" namespaced
+        # logs as long as we have a valid level.
+        if level
+          logger = Log4r::Logger.new("vagrant_compose")
+          logger.outputters = Log4r::Outputter.stderr
+          logger.level = level
+          logger = nil
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/compose/util/cluster.rb

@@ -0,0 +1,207 @@
+require_relative "node_group"
+
+# Definisce un cluster, ovvero l'insieme di 1..n gruppi di nodi con caratteristiche simili.
+class Cluster
+
+  attr_reader   :name
+  attr_reader   :multimachine_filter
+  attr_accessor :box
+  attr_accessor :domain
+  attr_accessor :ansible_playbook_path
+  attr_accessor :ansible_context_vars
+  attr_accessor :ansible_group_vars
+  attr_accessor :ansible_host_vars
+
+  # Costruttore di una istanza di cluster.
+  def initialize(name)
+    @group_uid             = 0
+    @node_groups           = {}
+    @ansible_context_vars  = {}
+    @ansible_group_vars    = {}
+    @ansible_host_vars     = {}
+    @multimachine_filter   = ""
+    @ansible_playbook_path = File.join(Dir.pwd, 'provisioning')
+
+    @name        = name 
+    @box         = 'ubuntu/trusty64'
+    @domain      = 'vagrant'
+  end   
+
+  # Metodo per la creazione di un gruppo di nodi; in fase di creazione, il blocco inizializza
+  # i valori/le expressioni da utilizzarsi nella valorizzazione degli attributi dei nodi in fase di compose.
+  #
+  # Oltre alla creazione dei nodi, il metodo prevede anche l'esecuzione di un blocco di codice per
+  # la configurazione del gruppo di nodi stesso.
+  def nodes(name, &block)
+    raise RuntimeError, "Nodes #{name} already exists in this cluster." unless not @node_groups.has_key?(name)
+
+    @node_groups[name] = NodeGroup.new(@group_uid, name)
+    @node_groups[name].box        = @box 
+    @node_groups[name].boxname    = lambda { |group_uid, group_name, node_index| return "#{group_name}#{node_index + 1}" }
+    @node_groups[name].hostname   = lambda { |group_uid, group_name, node_index| return "#{group_name}#{node_index + 1}" }
+    @node_groups[name].aliases    = []
+    @node_groups[name].ip         = lambda { |group_uid, group_name, node_index| return "172.31.#{group_uid}.#{100 + node_index + 1}" }
+    @node_groups[name].cpus       = 1
+    @node_groups[name].memory     = 256
+    @node_groups[name].ansible_groups = []
+    @node_groups[name].attributes = {}
+
+    @group_uid += 1 
+
+    block.call(@node_groups[name])
+  end 
+
+  # Prepara il provisioning del cluster
+  def compose 
+
+    @multimachine_filter =  ARGV.length > 1 ? ARGV[1] : "" # detect if running vagrant up/provision MACHINE
+
+    ## Fase1: Creazione dei nodi
+
+    # sviluppa i vari gruppi di nodi, creando i singoli nodi
+    nodes = []
+
+    @node_groups.each do |key, group| 
+      group.compose(@name, @domain, nodes.size) do |node|
+        nodes << node
+      end
+    end
+
+    # sviluppa i gruppi abbinando a ciascono i nodi creati
+    # NB. tiene in considerazione anche l'eventualità che un gruppo possa essere composto da nodi appartenenti a diversi node_groups
+    ansible_groups= {}
+    nodes.each do |node|
+      node.ansible_groups.each do |ansible_group|
+        ansible_groups[ansible_group] = [] unless ansible_groups.has_key? (ansible_group)
+        ansible_groups[ansible_group] << node
+      end  
+    end
+
+    ## Fase2: Configurazione provisioning del cluster via Ansible
+    # Ogni nodo diventerà una vm su cui sarà fatto il provisioning, ovvero un host nell'inventory di ansible 
+    # Ad ogni gruppo corrispondono nodi con caratteristiche simili
+
+    # genearazione inventory file per ansible, aka ansible_groups in Vagrant (NB. 1 group = 1 gruppo ansible)
+    ansible_groups_provision = {}
+    ansible_groups.each do |ansible_group, ansible_group_nodes|
+      ansible_groups_provision[ansible_group] = []
+      ansible_group_nodes.each do |node|
+        ansible_groups_provision[ansible_group] << node.hostname if @multimachine_filter.empty? or @multimachine_filter == node.boxname #filter ansible groups if vagrant command on one node
+      end  
+    end
+    ansible_groups_provision['all_groups:children'] = ansible_groups.keys
+
+    # Oltre alla creazione del file di inventory per ansible, contenente gruppi e host, è supportata:
+    # - la creazione di file ansible_group_vars, ovvero di file preposti a contenere una serie di variabili - specifico di ogni gruppo di host  -
+    #   per condizionare il provisioning ansible sulla base delle caratteristiche del cluster specifico
+    # - la creazione di file ansible_host_vars, ovvero di file preposti a contenere una serie di variabili - specifico di ogni host -
+    #   per condizionare il provisioning ansible sulla base delle caratteristiche del cluster specifico
+
+    # La generazione delle variabili utilizza una serie di VariableProvisioner, uno o più d'uno per ogni gruppo di hosts, configurati durante la
+    # definizione del cluster.
+
+    context = {}
+
+    #genearazione context (NB. 1 group = 1 gruppo host ansible)
+    ansible_groups.each do |ansible_group, ansible_group_nodes|
+      
+      # genero le variabili per il group
+      provisioners = @ansible_context_vars[ansible_group]
+      unless provisioners.nil?
+        # se necessario, normalizzo provisioner in array provisioners
+        provisioners = [ provisioners ] if not provisioners.respond_to?('each') 
+        # per tutti i provisioners abbinati al ruolo        
+        provisioners.each do |provisioner|
+          begin
+            vars = provisioner.call(context, ansible_group_nodes)
+
+            #TODO: gestire conflitto (n>=2 gruppi che generano la stessa variabile - con valori diversi)
+            context = context.merge(vars)
+          rescue Exception => e
+            raise VagrantPlugins::Compose::Errors::ContextVarExpressionError, :message => e.message, :ansible_group => ansible_group
+          end
+        end  
+      end
+    end
+
+    # cleanup ansible_group_vars files
+    # TODO: make variable public
+    @ansible_group_vars_path = File.join(@ansible_playbook_path, 'group_vars')
+    # TODO: make safe
+    FileUtils.mkdir_p(@ansible_group_vars_path) unless File.exists?(@ansible_group_vars_path)
+    Dir.foreach(@ansible_group_vars_path) {|f| fn = File.join(@ansible_group_vars_path, f); File.delete(fn) if f.end_with?(".yml")}
+
+    #generazione ansible_group_vars file (NB. 1 group = 1 gruppo host ansible)
+    ansible_groups.each do |ansible_group, ansible_group_nodes|
+      ansible_group_vars = {}
+      # genero le variabili per il group
+      provisioners = @ansible_group_vars[ansible_group]
+      unless provisioners.nil?
+        # se necessario, normalizzo provisioner in array provisioners
+        provisioners = [ provisioners ] if not provisioners.respond_to?('each') 
+        # per tutti i provisioners abbinati al ruolo        
+        provisioners.each do |provisioner|
+          begin
+            vars = provisioner.call(context, ansible_group_nodes)
+
+            #TODO: gestire conflitto (n>=2 gruppi che generano la stessa variabile - con valori diversi)
+            ansible_group_vars = ansible_group_vars.merge(vars)
+          rescue Exception => e
+            raise VagrantPlugins::Compose::Errors::GroupVarExpressionError, :message => e.message, :ansible_group => ansible_group
+          end
+        end  
+      end
+
+      # crea il file (se sono state generate delle variabili)
+      unless ansible_group_vars.empty?
+        # TODO: make safe  
+        File.open(File.join(@ansible_group_vars_path,"#{ansible_group}.yml") , 'w+') do |file|
+          file.puts YAML::dump(ansible_group_vars)
+        end 
+      end
+    end
+
+    # cleanup ansible_host_vars files (NB. 1 nodo = 1 host)
+    # TODO: make variable public
+    @ansible_host_vars_path = File.join(@ansible_playbook_path, 'host_vars')
+    # TODO: make safe
+    FileUtils.mkdir_p(@ansible_host_vars_path) unless File.exists?(@ansible_host_vars_path)
+    Dir.foreach(@ansible_host_vars_path) {|f| fn = File.join(@ansible_host_vars_path, f); File.delete(fn) if f.end_with?(".yml")}
+
+    #generazione ansible_host_vars file
+    nodes.each do |node|
+      # genero le variabili per il nodo; il nodo, può essere abbinato a diversi gruppi
+      ansible_host_vars = {}
+      node.ansible_groups.each do |ansible_group|
+        # genero le variabili per il gruppo
+        provisioners = @ansible_host_vars[ansible_group]
+        unless provisioners.nil?
+          # se necessario, normalizzo provisioner in array provisioners
+          provisioners = [ provisioners ] if not provisioners.respond_to?('each') 
+          # per tutti i provisioners abbinati al gruppo
+          provisioners.each do |provisioner|
+            begin
+              vars = provisioner.call(context, node)
+
+              #TODO: gestire conflitto (n>=2 gruppi che generano la stessa variabile - con valori diversi)
+              ansible_host_vars = ansible_host_vars.merge(vars)
+            rescue Exception => e
+              raise VagrantPlugins::Compose::Errors::HostVarExpressionError, :message => e.message, :host => node.hostname, :ansible_group => ansible_group
+            end
+          end  
+        end
+      end
+
+      # crea il file (se sono state generate delle variabili)
+      unless ansible_host_vars.empty?
+        # TODO: make safe  
+        File.open(File.join(@ansible_host_vars_path,"#{node.hostname}.yml") , 'w+') do |file|
+          file.puts YAML::dump(ansible_host_vars)
+        end 
+      end
+    end
+
+    return nodes.map.with_index, ansible_groups_provision
+  end
+
+end 

data/lib/vagrant/compose/util/node.rb

@@ -0,0 +1,30 @@
+# Definisce un nodo, ovvero uno delle istanze di nodi che compongono il cluster
+class Node
+  attr_reader :box
+  attr_reader :boxname
+  attr_reader :hostname
+  attr_reader :fqdn
+  attr_reader :aliases
+  attr_reader :ip
+  attr_reader :cpus
+  attr_reader :memory
+  attr_reader :ansible_groups
+  attr_reader :attributes
+  attr_reader :index
+  attr_reader :group_index
+
+  def initialize(box, boxname, hostname, fqdn, aliases, ip, cpus, memory, ansible_groups, attributes, index, group_index) 
+    @box            = box
+    @boxname        = boxname
+    @hostname       = hostname
+    @fqdn           = fqdn
+    @aliases        = aliases
+    @ip             = ip
+    @cpus           = cpus
+    @memory         = memory
+    @ansible_groups = ansible_groups
+    @attributes     = attributes
+    @index          = index
+    @group_index    = group_index
+  end 
+end

data/lib/vagrant/compose/util/node_group.rb

@@ -0,0 +1,58 @@
+require_relative "node"
+
+# Definisce un node group, ovvero un insieme di nodi con caratteristiche omogenee.
+# i singoli nodi del gruppo, sono generati in fase di compose tramite delle espressioni 
+# che generano i valori degli attributi che caratterizzano ogni nodo 
+class NodeGroup 
+  attr_reader :uid, :name
+  attr_accessor :instances
+  attr_accessor :box
+  attr_accessor :boxname
+  attr_accessor :hostname
+  attr_accessor :aliases
+  attr_accessor :ip
+  attr_accessor :cpus
+  attr_accessor :memory
+  attr_accessor :ansible_groups
+  attr_accessor :attributes
+
+  def initialize(uid, name)  
+    @uid  = uid
+    @name = name
+    @instances = 1
+  end  
+
+  # compone il gruppo, generando le istanze dei vari nodi
+  def compose(cluster_name, cluster_domain, cluster_offset)
+    node_index = 0
+    while node_index < @instances
+      box            = generate(:box, @box, node_index) 
+      boxname        = "#{cluster_name}-#{generate(:boxname, @boxname, node_index)}" 
+      hostname       = "#{cluster_name}-#{generate(:hostname, @hostname, node_index)}" 
+      aliases        = generate(:aliases, @aliases, node_index).join(',')
+      fqdn           = "#{hostname}.#{cluster_domain}"
+      ip             = generate(:ip, @ip, node_index)
+      cpus           = generate(:cpus, @cpus, node_index)
+      memory         = generate(:memory, @memory, node_index) 
+      ansible_groups = generate(:ansible_groups, @ansible_groups, node_index)
+      attributes     = generate(:attributes, @attributes, node_index)
+      yield Node.new(box, boxname, hostname, fqdn, aliases, ip, cpus, memory, ansible_groups, attributes, cluster_offset + node_index, node_index)
+
+      node_index += 1
+    end
+  end
+
+  # funzione di utilità per l'esecuzione delle espressioni che generano 
+  # i valori degli attributi
+  def generate(var, generator, node_index)
+    unless generator.respond_to? :call
+      return generator
+    else
+      begin
+        return generator.call(@uid, @name, node_index) 
+      rescue Exception => e
+        raise VagrantPlugins::Compose::Errors::AttributeExpressionError, :message => e.message, :attribute => var, :node_index => node_index, :node_group_name => name
+      end
+    end
+  end
+end 

data/lib/vagrant/compose/version.rb

@@ -0,0 +1,5 @@
+module Vagrant
+  module Compose
+    VERSION = "0.1.0"
+  end
+end

data/provisioning/group_vars/zookeeper.yml

@@ -0,0 +1,2 @@
+---
+x: 1

data/vagrant-compose.gemspec

@@ -0,0 +1,55 @@
+$:.unshift File.expand_path("../lib", __FILE__)
+require 'vagrant/compose/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "vagrant-compose"
+  spec.version       = Vagrant::Compose::VERSION
+  spec.platform      = Gem::Platform::RUBY
+  spec.license       = "MIT"
+  spec.authors       = ["Fabrizio Pandini"]
+  spec.email         = ["fabrizio.pandini@unicredit.eu"]
+  spec.homepage      = "https://github.com/fabriziopandini/vagrant-compose/"  
+  spec.summary       = %q{A Vagrant plugin that helps building complex multi-machine scenarios.}
+  spec.description   = %q{A Vagrant plugin that helps building complex multi-machine scenarios.}
+
+  spec.required_rubygems_version = ">= 2.0.13"
+
+  spec.add_development_dependency "rake", "~> 10.4.2"
+  spec.add_development_dependency "rspec", "~> 3.4.0"
+  spec.add_development_dependency "rspec-its", "~> 1.2.0"
+
+  # The following block of code determines the files that should be included
+  # in the gem. It does this by reading all the files in the directory where
+  # this gemspec is, and parsing out the ignored files from the gitignore.
+  # Note that the entire gitignore(5) syntax is not supported, specifically
+  # the "!" syntax, but it should mostly work correctly.
+  root_path      = File.dirname(__FILE__)
+  all_files      = Dir.chdir(root_path) { Dir.glob("**/{*,.*}") }
+  all_files.reject! { |file| [".", ".."].include?(File.basename(file)) }
+  gitignore_path = File.join(root_path, ".gitignore")
+  gitignore      = File.readlines(gitignore_path)
+  gitignore.map!    { |line| line.chomp.strip }
+  gitignore.reject! { |line| line.empty? || line =~ /^(#|!)/ }
+
+  unignored_files = all_files.reject do |file|
+    # Ignore any directories, the gemspec only cares about files
+    next true if File.directory?(file)
+
+    # Ignore any paths that match anything in the gitignore. We do
+    # two tests here:
+    #
+    #   - First, test to see if the entire path matches the gitignore.
+    #   - Second, match if the basename does, this makes it so that things
+    #     like '.DS_Store' will match sub-directories too (same behavior
+    #     as git).
+    #
+    gitignore.any? do |ignore|
+      File.fnmatch(ignore, file, File::FNM_PATHNAME) ||
+        File.fnmatch(ignore, File.basename(file), File::FNM_PATHNAME)
+    end
+  end
+ 
+  spec.files         = unignored_files
+  spec.executables   = unignored_files.map { |f| f[/^bin\/(.*)/, 1] }.compact
+  spec.require_path  = 'lib'
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: vagrant-compose
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Fabrizio Pandini
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.4.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.4.2
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+description: A Vagrant plugin that helps building complex multi-machine scenarios.
+email:
+- fabrizio.pandini@unicredit.eu
+executables:
+- console
+- setup
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/console
+- bin/setup
+- CHANGELOG.md
+- Gemfile
+- lib/locales/en.yml
+- lib/vagrant/compose/config.rb
+- lib/vagrant/compose/errors.rb
+- lib/vagrant/compose/plugin.rb
+- lib/vagrant/compose/util/cluster.rb
+- lib/vagrant/compose/util/node.rb
+- lib/vagrant/compose/util/node_group.rb
+- lib/vagrant/compose/version.rb
+- lib/vagrant/compose.rb
+- LICENCE
+- provisioning/group_vars/zookeeper.yml
+- Rakefile
+- README.md
+- vagrant-compose.gemspec
+- .gitignore
+- .rspec
+- .travis.yml
+homepage: https://github.com/fabriziopandini/vagrant-compose/
+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: 2.0.13
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: A Vagrant plugin that helps building complex multi-machine scenarios.
+test_files: []