vagrant-hivemind 0.1.0

data/lib/vagrant/hivemind/commands/spawn.rb

@@ -0,0 +1,95 @@
+require "optparse"
+
+require "vagrant/hivemind/constants"
+require "vagrant/hivemind/util"
+require "vagrant/hivemind/host"
+
+module Vagrant
+  module Hivemind
+    module Command
+      class Spawn < Vagrant.plugin("2", :command)
+          include Vagrant::Hivemind::Constants
+          include Vagrant::Hivemind::Util
+
+        def self.synopsis
+          "Creates a new Drone in the Hive"
+        end
+
+        def execute
+          options = {}
+
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant hivemind spawn [options]"
+            o.separator ""
+            o.separator "Options:"
+            o.separator ""
+
+            o.on("-n", "--hostname HOSTNAME", "The hostname of the Drone (REQUIRED)") do |n|
+              options[:hostname] = n
+            end
+
+            o.on("-c", "--control", "Assign the Drone to be a Control Machine") do |c|
+              options[:control] = c
+            end
+
+            o.on("-s", "--size SIZE", BOX_SIZES.keys.map(&:to_s), "The Box Size of the Drone #{BOX_SIZES.keys.map(&:to_s)} (default: :small)") do |s|
+              options[:size] = s
+            end
+
+            o.on("-t", "--type TYPE", BOX_TYPES.keys.map(&:to_s), "The Box Type of the Drone #{BOX_TYPES.keys.map(&:to_s)} (default: :server)") do |t|
+              options[:type] = t
+            end
+
+            o.on("-d", "--directory DIRECTORY", "Specify the directory where '#{HIVE_FILE}' is located (default: current directory)") do |d|
+              options[:directory] = []
+              options[:directory] << d
+            end
+          end
+
+          argv = parse_options(opts)
+          return if !argv
+
+          unless options[:hostname]
+            @env.ui.info opts.help
+            return 0
+          end
+
+          root_path = Path.get_root_path_from_options options
+
+          unless HiveFile.exist? root_path
+            @env.ui.error "There is no Hive file in the working directory."
+            return 1
+          end
+
+          hosts = HiveFile.read_from root_path
+
+          if hosts.values.map(&:hostname).include? options[:hostname]
+            @env.ui.error "The specified hostname already exists!"
+            return 1
+          end
+
+          unless Network.is_valid_hostname? options[:hostname]
+            @env.ui.error "Invalid hostname format!"
+            return 1
+          end
+
+          drone = {
+            options[:hostname] => Vagrant::Hivemind::Host.new(
+              options[:hostname],
+              Network.next_ip_address(hosts),
+              {
+                is_control: options[:control],
+                box_size:   options[:size],
+                box_type:   options[:type]
+              })
+          }
+          HiveFile.write_to hosts.merge(drone), root_path
+          @env.ui.info "Spawned the Drone with hostname '#{options[:hostname]}'"
+
+          0
+        end
+
+      end
+    end
+  end
+end

data/lib/vagrant/hivemind/commands/up.rb

@@ -0,0 +1,102 @@
+require "optparse"
+require "erb"
+
+require "vagrant/hivemind/constants"
+require "vagrant/hivemind/util"
+require "vagrant/hivemind/host"
+
+module Vagrant
+  module Hivemind
+    module Command
+      class Up < Vagrant.plugin("2", :command)
+          include Vagrant::Hivemind::Constants
+          include Vagrant::Hivemind::Util
+
+        def self.synopsis
+          "Starts and provisions a Drone in the Hive"
+        end
+
+        def execute
+          options = {}
+
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant hivemind up [options]"
+            o.separator ""
+            o.separator "Options:"
+            o.separator ""
+
+            o.on("-n", "--hostname HOSTNAME", "The hostname of the Drone (REQUIRED)") do |n|
+              options[:hostname] = n
+            end
+
+            o.on("-d", "--directory DIRECTORY", "Specify the directory where '#{HIVE_FILE}' is located (default: current directory)") do |d|
+              options[:directory] = []
+              options[:directory] << d
+            end
+          end
+
+          argv = parse_options(opts)
+          return if !argv
+
+          unless options[:hostname]
+            @env.ui.info opts.help
+            return 0
+          end
+
+          root_path = Path.get_root_path_from_options options
+
+          unless HiveFile.exist? root_path
+            @env.ui.error "There is no Hive file in the working directory."
+            return 1
+          end
+
+          hosts = HiveFile.read_from root_path
+
+          unless hosts.values.map(&:hostname).include? options[:hostname]
+            @env.ui.error "The specified hostname does not exist!"
+            return 1
+          end
+
+          host = hosts[options[:hostname]]
+
+          Vagrant::Hivemind::Util::Vagrantfile.generate_hivemind_vagrantfile @env, host, root_path
+          Ansible.generate_hosts_file hosts, Path.local_data_path(root_path)
+          HostsFile.generate_hosts_file hosts, Path.local_data_path(root_path)
+
+          machines = []
+          @env.batch do |batch|
+            with_target_vms(options[:hostname]) do |machine|
+              @env.ui.info(I18n.t("vagrant.commands.up.upping",
+                name: machine.name,
+                provider: machine.provider_name))
+
+              machines << machine
+
+              batch.action(machine, :up, options)
+            end
+          end
+
+          if machines.empty?
+            @env.ui.info(I18n.t("vagrant.up_no_machines"))
+            return 1
+          end
+
+          machines.each do |m|
+            next if !m.config.vm.post_up_message
+            next if m.config.vm.post_up_message == ""
+
+            @env.ui.info("", prefix: false)
+
+            m.ui.success(I18n.t(
+              "vagrant.post_up_message",
+              name: m.name.to_s,
+              message: m.config.vm.post_up_message))
+          end
+
+          0
+        end
+
+      end
+    end
+  end
+end

data/lib/vagrant/hivemind/constants.rb

@@ -0,0 +1,38 @@
+module Vagrant
+  module Hivemind
+    module Constants
+      HIVE_FILE = "hive.yml"
+      ANSIBLE_HOSTS_FILE = "ansible.hosts"
+      SYSTEM_HOSTS_FILE = "system.hosts"
+
+      BOX_TYPES = {
+        :server    => { name: "Server",     box_id: "napramirez/ubuntu-14.04.2-LTS-amd64-server",      is_gui: false },
+        :kde       => { name: "KDE",        box_id: "napramirez/kubuntu-14.04.2-LTS-amd64-lite",       is_gui: true },
+        :unity     => { name: "Unity",      box_id: "napramirez/ubuntu-14.04.2-LTS-amd64-desktoplite", is_gui: true },
+        :unityi386 => { name: "Unity i386", box_id: "napramirez/ubuntu-14.04.2-LTS-i386-desktoplite",  is_gui: true }
+      }
+
+      BOX_SIZES = {
+        :extra_small => { name: "Extra Small", short_name: "xs", memory_in_mb:  256 },
+        :small       => { name: "Small",       short_name: "s",  memory_in_mb:  512 },
+        :medium      => { name: "Medium",      short_name: "m",  memory_in_mb: 1024 },
+        :large       => { name: "Large",       short_name: "l",  memory_in_mb: 2048 },
+        :extra_large => { name: "Extra Large", short_name: "xl", memory_in_mb: 4096 }
+      }
+
+      CONTROL_HOSTNAME = "control"
+
+      PRIVATE_NETWORK = "192.168.50.*"
+      PRIVATE_NETWORK_START = 100
+      PRIVATE_NETWORK_END   = 254
+      PRIVATE_NETWORK_IP_ADDRESS_POOL = (PRIVATE_NETWORK_START..PRIVATE_NETWORK_END).map { |i| PRIVATE_NETWORK.sub('*', "#{i}") }
+
+      SIMPLE_HOSTNAME_REGEX = /^[A-Za-z0-9]+([\-]{0,1}[A-Za-z0-9]+)*$/
+      SIMPLE_HOSTNAME_MAX_LENGTH = 20
+
+      IP_ADDRESS_REGEX = /^([01]?[0-9]?[0-9]|2[0-4][0-9]|25[0-5])\.([01]?[0-9]?[0-9]|2[0-4][0-9]|25[0-5])\.([01]?[0-9]?[0-9]|2[0-4][0-9]|25[0-5])\.([01]?[0-9]?[0-9]|2[0-4][0-9]|25[0-5])$/
+
+      PORT_PAIR_REGEX = /^[0-9]{1,5}\:[0-9]{1,5}$/
+    end
+  end
+end

data/lib/vagrant/hivemind/host.rb

@@ -0,0 +1,34 @@
+require_relative "constants"
+
+module Vagrant
+  module Hivemind
+    class Host
+      attr_accessor :hostname, :ip_address, :is_control, :box_size, :box_type, :forwarded_ports
+      @control = nil
+
+      def initialize(hostname, ip_address, options = {})
+        @hostname   = hostname
+        @ip_address = ip_address
+        @is_control = options[:is_control] || false
+        @box_size   = options[:box_size]   || :small.to_s
+        @box_type   = options[:box_type]   || :server.to_s
+        @forwarded_ports = []
+      end
+
+      def self.control
+        unless @control
+          @control = self.new(
+            Constants::CONTROL_HOSTNAME,
+            Util::Network.starting_ip_address,
+            {
+              is_control: true,
+              box_size:   :small.to_s,
+              box_type:   :server.to_s
+            })
+        end
+        @control
+      end
+
+    end
+  end
+end

data/lib/vagrant/hivemind/plugin.rb

@@ -0,0 +1,16 @@
+require "vagrant"
+
+module Vagrant
+  module Hivemind
+    class Plugin < Vagrant.plugin("2")
+      name "Hivemind"
+      description "Vagrant extension directives for the Hivemind platform"
+
+      command "hivemind" do
+        require_relative "commands/root"
+        Command::Root
+      end
+
+    end
+  end
+end

data/lib/vagrant/hivemind/util.rb

@@ -0,0 +1,236 @@
+require "yaml"
+require "erb"
+
+require_relative "constants"
+
+module Vagrant
+  module Hivemind
+    module Util
+
+      class HiveFile
+        def self.exist?(path = Pathname.new(Dir.pwd))
+          File.exist? get_hive_file_from_path path
+        end
+
+        def self.read_from(path = Pathname.new(Dir.pwd))
+          hive_file = get_hive_file_from_path path
+          hosts_from_hive_file = {}
+          hosts_from_hive_file = YAML.load_file(hive_file) if File.exist? hive_file
+          hosts_from_hive_file
+        end
+
+        def self.write_to(hosts = {}, path = Pathname.new(Dir.pwd))
+          hive_file = get_hive_file_from_path path
+          File.open(hive_file, "w+") do |f|
+            f.write(hosts.to_yaml)
+          end
+        end
+
+        private
+          def self.get_hive_file_from_path(path)
+            if File.directory? path
+              File.join(path, Vagrant::Hivemind::Constants::HIVE_FILE)
+            else
+              path
+            end
+          end
+      end
+
+      class Network
+        def self.is_valid_hostname?(hostname)
+          return false unless hostname and hostname.size > 0 and hostname.size <= Vagrant::Hivemind::Constants::SIMPLE_HOSTNAME_MAX_LENGTH
+          return (Vagrant::Hivemind::Constants::SIMPLE_HOSTNAME_REGEX =~ hostname) != nil
+        end
+
+        def self.is_valid_ip_address?(ip_address)
+          return false unless ip_address and ip_address.split(".").size == 4
+          return (Vagrant::Hivemind::Constants::IP_ADDRESS_REGEX =~ ip_address) != nil
+        end
+
+        def self.is_valid_port_pair?(port_pair)
+          return false unless port_pair and port_pair.split(":").size == 2
+          return (Vagrant::Hivemind::Constants::PORT_PAIR_REGEX =~ port_pair) != nil
+        end
+
+        def self.is_valid_port_value?(port)
+          port >= 0 and port <= 65535
+        end
+
+        def self.port_pair_to_i(port_pair)
+          port_pair.split(":").map.each { |n| n.to_i }
+        end
+
+        def self.get_host_port_pair_with_guest_port(guest_port, host)
+          (host.forwarded_ports.select do |forwarded_port| forwarded_port["guest_port"] == guest_port end).first
+        end
+
+        def self.get_host_keys_using_host_port(host_port, hosts)
+          hosts.keys.select do |key|
+            host = hosts[key]
+            host.forwarded_ports and (
+              host.forwarded_ports.select do |forwarded_port|
+                forwarded_port["host_port"] == host_port
+              end).size > 0
+          end
+        end
+
+        def self.get_network(ip_address)
+          split_ip_address = ip_address.split(".")
+          return nil unless split_ip_address.size == 4
+          split_ip_address[0,3].join(".")
+        end
+
+        def self.starting_ip_address
+          Vagrant::Hivemind::Constants::PRIVATE_NETWORK_IP_ADDRESS_POOL[0]
+        end
+
+        def self.highest_ip_address(hosts = {})
+          hosts.values.map(&:ip_address).sort.last
+        end
+
+        def self.next_ip_address(hosts = {})
+          highest_ip_address_index = Vagrant::Hivemind::Constants::PRIVATE_NETWORK_IP_ADDRESS_POOL.find_index highest_ip_address(hosts)
+
+          next_ip_address_index = highest_ip_address_index
+          loop do
+            next_ip_address_index = ((next_ip_address_index + 1) % Vagrant::Hivemind::Constants::PRIVATE_NETWORK_IP_ADDRESS_POOL.size)
+            next_ip_address_candidate = Vagrant::Hivemind::Constants::PRIVATE_NETWORK_IP_ADDRESS_POOL[next_ip_address_index]
+
+            return next_ip_address_candidate unless hosts.values.map(&:ip_address).include? next_ip_address_candidate
+
+            if next_ip_address_index == highest_ip_address_index
+              raise StandardError, "There are no more available ip addresses for the private network!"
+            end
+          end
+        end
+      end
+
+      class Path
+        def self.get_root_path_from_options(options = {})
+          path = options[:directory] ||= [Dir.pwd]
+          root_path path.first
+        end
+
+        def self.cache_path
+          cache_path = Pathname.new(Dir.tmpdir).join "hivemind"
+          Dir.mkdir cache_path unless cache_path.directory?
+          cache_path
+        end
+
+        def self.hivemind_home_path
+          Pathname.new File.expand_path("../../../../", __FILE__)
+        end
+
+        def self.root_path(path = Pathname.new(Dir.pwd))
+          Pathname.new File.expand_path path, Pathname.new(Dir.pwd)
+        end
+
+        def self.local_data_path(path = Pathname.new(Dir.pwd))
+          local_data_path = root_path(path).join ".vagrant"
+          Dir.mkdir local_data_path unless local_data_path.directory?
+          local_data_path
+        end
+      end
+
+      class Vagrantfile
+        def self.generate_hivemind_vagrantfile(env, host, path = Pathname.new(Dir.pwd))
+          box_types = Vagrant::Hivemind::Constants::BOX_TYPES
+          box_sizes = Vagrant::Hivemind::Constants::BOX_SIZES
+          cache_path = Path.cache_path
+          hivemind_home_path = Path.hivemind_home_path
+          local_data_path = Path.local_data_path path
+          b = binding
+
+          template_string = ""
+          File.open(File.expand_path("../../../../templates/Vagrantfile.erb", __FILE__), "r") do |f|
+            template_string = f.read
+          end
+
+          template = ERB.new template_string
+          template_result = template.result(b)
+
+          tf = Tempfile.new("Hivemind_Vagrantfile", path)
+          tf.write template_result
+          tf.close
+
+          env.define_singleton_method :vagrantfile_name= do |vfn| @vagrantfile_name = vfn end
+          env.define_singleton_method :root_path= do |root_path| @root_path = root_path end
+          env.define_singleton_method :local_data_path= do |local_data_path| @local_data_path = local_data_path end
+          env.vagrantfile_name = [File.basename(tf)]
+          env.root_path = path
+          env.local_data_path = local_data_path
+
+          nil
+        end
+      end
+
+      class Ansible
+        def self.generate_hosts_file(hosts = {}, path = Pathname.new(Dir.pwd))
+          datetime_now = DateTime.now.strftime "%F %T %p"
+          b = binding
+
+          template_string = ""
+          File.open(File.expand_path("../../../../templates/ansible.hosts.erb", __FILE__), "r") do |f|
+            template_string = f.read
+          end
+
+          template = ERB.new template_string
+          template_result = template.result(b)
+
+          ansible_hosts_file = get_ansible_hosts_file_from_path path
+          File.open(ansible_hosts_file, "w+") do |f|
+            f.write(template_result)
+          end
+        end
+
+        def self.read_from(path = Pathname.new(Dir.pwd))
+          ansible_hosts_file = get_ansible_hosts_file_from_path path
+          ansible_hosts = ""
+          File.open() do |f|
+            ansible_hosts = f.read
+          end
+          ansible_hosts
+        end
+
+        private
+          def self.get_ansible_hosts_file_from_path(path)
+            if File.directory? path
+              File.join(path, Vagrant::Hivemind::Constants::ANSIBLE_HOSTS_FILE)
+            else
+              path
+            end
+          end
+      end
+
+      class HostsFile
+        def self.generate_hosts_file(hosts = {}, path = Pathname.new(Dir.pwd))
+          datetime_now = DateTime.now.strftime "%F %T %p"
+          b = binding
+
+          template_string = ""
+          File.open(File.expand_path("../../../../templates/system.hosts.erb", __FILE__), "r") do |f|
+            template_string = f.read
+          end
+
+          template = ERB.new template_string
+          template_result = template.result(b)
+
+          system_hosts_file = get_system_hosts_file_from_path path
+          File.open(system_hosts_file, "w+") do |f|
+            f.write(template_result)
+          end
+        end
+
+        private
+          def self.get_system_hosts_file_from_path(path)
+            if File.directory? path
+              File.join(path, Vagrant::Hivemind::Constants::SYSTEM_HOSTS_FILE)
+            else
+              path
+            end
+          end
+      end
+
+    end
+  end
+end