vagrant-subutai 1.0.0

data/lib/vagrant-subutai/packer/subutai_hooks.rb

@@ -0,0 +1,62 @@
+# Functions dealing with hook scripts
+
+# True if script starts with #!/bin/bash
+# --------------------------------------
+def shebang?(bash_hook)
+  text = File.open(bash_hook).read
+  text.gsub!(/\r\n?/, "\n")
+  line = text.next
+  return true if line.start_with? '#!/bin/bash'
+  true if line.start_with? '#!/usr/bin/env bash'
+end
+
+# Handle hook scripts or normal files: returns path to file to provision
+# ----------------------------------------------------------------------
+def hook_handler(hook)
+  # hook might be the upload file or an executable to give the path to the
+  # file to be provisioned. Builders can use this to hook into the
+  # provisioning process for new snaps and management templates.
+  unless File.executable?(hook)
+    puts '[WARNING] hook script ' + hook + ' not executable. Abandoning launch.'
+    return nil
+  end
+
+  fext = File.extname(hook)
+  if fext == '.sh' && shebang?(hook)
+    `#{hook}`.strip # executes and returns output (should be file)
+  # elsif fext == '.bat'
+  #   return `#{hook}`.strip # executes and returns output (should be file)
+  else
+    # raise '[WARNING] hook script not valid bash .sh or .bat. Abandoning launch.'
+    raise '[WARNING] hook script not valid bash file with .sh extension. Abandoning launch.'
+  end
+end
+
+# TODO: Match extension to OS and pick appropriately if
+# both a .bat and .sh are present.
+
+# If arg is nil check for presence of snap_hook.${ext}
+# ----------------------------------------------------
+def snap_handler(hook)
+  if hook.nil?
+    %w[.sh .bat].each do |e|
+      return hook_handler('./snap_hook' + e) if File.exist?('./snap_hook' + e)
+    end
+    return nil
+  end
+  hook_handler(hook)
+end
+
+# if arg is nil check for presence of management_hook.${ext}
+# ----------------------------------------------------
+def management_handler(hook)
+  if hook.nil?
+    %w[.sh .bat].each do |e|
+      if File.exist?('./management_hook' + e)
+        return hook_handler('management_hook' + e)
+      end
+    end
+    return nil
+  end
+  hook_handler(hook)
+end

data/lib/vagrant-subutai/packer/subutai_net.rb

@@ -0,0 +1,125 @@
+require 'socket'
+require 'timeout'
+require 'rbconfig'
+require 'log4r'
+
+# methods dealing with port management
+
+# Checks if a port is not available
+# ---------------------------------
+def port_bound?(host, port)
+  Timeout.timeout(1) do
+    s = TCPSocket.new(host, port)
+    s.close rescue nil
+    return true
+  end
+rescue Timeout::Error, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, \
+       Errno::ENETUNREACH, Errno::EACCES, Errno::ENOTCONN, \
+       Errno::EADDRNOTAVAIL
+  return false
+end
+
+# Finds free port for console and puts in wormstore
+# -------------------------------------------------
+def find_port(port)
+  port += 1 while port_bound?('127.0.0.1', port)
+  port
+end
+
+# Most hypervisors uses a mac prefix: we cannot just generate a random mac
+PROVIDERS=%i[:virtualbox :libvirt :vmware_fusion :vmware :parallels :hyper_v]
+PROVIDER_MAC_PREFIXES = {
+    :virtualbox       => '080027',
+    :libvirt          => '525400',
+    :vmware_fusion    => '______',
+    :vmware           => '______',
+    :parallels        => '______',
+    :hyper_v          => '______'
+}
+
+os = nil
+os = :windows if (RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/)
+os = :mac     if (RbConfig::CONFIG['host_os'] =~ /darwin/)
+os = :linux   if (RbConfig::CONFIG['host_os'] =~ /linux/)
+
+def broadcast_addr
+  octets = `route print 0.0.0.0 | findstr 0.0.0.0`.split(' ').map(&:strip)[2].split('.')    \
+    if (RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/)
+  octets = `ip route show | grep default | awk '{print $3}'`.gsub(/\s+/, "").split(".")     \
+    if (RbConfig::CONFIG['host_os'] =~ /linux/)
+  octets = `route -n get default | grep gateway | awk '{print $2}'`.gsub(/\s+/, "").split(".") \
+    if (RbConfig::CONFIG['host_os'] =~ /darwin/)
+  octets[3] = 255
+  octets.join('.')
+end
+
+def broadcast_ping(count)
+  system("ping -n #{count} #{broadcast_addr} >/dev/null")   \
+    if (RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/)
+  system("ping -c #{count} #{broadcast_addr} >/dev/null")   \
+    if (RbConfig::CONFIG['host_os'] =~ /darwin|linux/)
+end
+
+def zero_pad_mac(mac)
+  reassembled = ''
+  mac.split(':').each do |octet|
+    octet = '0' + octet if octet.length == 1
+    reassembled += octet
+  end
+  reassembled
+end
+
+def arp_table
+  broadcast_ping(2)
+  arp_table = {}
+  `arp -a`.split("\n").each do |line|
+    matches = /.*(\d+\.\d+\.\d+.\d+)[[:space:]]((([a-f]|[0-9]){1,2}:){5}([a-f]|[0-9]){1,2})[[:space:]].*/.match(line) \
+      if (RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/)
+    matches = /.*\((\d+\.\d+\.\d+.\d+)\) at ((([a-f]|[0-9]){1,2}:){5}([a-f]|[0-9]){1,2}) .*/.match(line) \
+      if (RbConfig::CONFIG['host_os'] =~ /darwin|linux/)
+
+    if ! matches.nil? && ! matches[2].nil?
+      key_mac = zero_pad_mac(matches[2])
+      value_ip = matches[1]
+      arp_table.store(key_mac, value_ip)
+    end
+  end
+  arp_table
+end
+
+def mac_uniq?(mac)
+  arptab = arp_table
+  arptab[mac].nil?
+end
+
+def find_mac(provider)
+  mac = random_mac_addr(provider)
+  until mac_uniq?(mac) do
+    mac = random_mac_addr(provider)
+  end
+  mac
+end
+
+# Generate a random mac address that works with the hypervisor of a provider
+def random_mac_addr(provider)
+  symbol = provider.to_sym
+  case symbol
+    when :virtualbox
+      PROVIDER_MAC_PREFIXES[:virtualbox] + 3.times.map { '%02x' % rand(0..255) }.join
+    when :libvirt
+      PROVIDER_MAC_PREFIXES[:libvirt] + 3.times.map { '%02x' % rand(0..255) }.join
+    when :vmware_fusion
+      # PROVIDER_MAC_PREFIXES[:vmware_fusion] + 3.times.map { '%02x' % rand(0..255) }.join
+      raise "Unsupported provider #{provider}"
+    when :vmware
+      # PROVIDER_MAC_PREFIXES[:vmware] + 3.times.map { '%02x' % rand(0..255) }.join
+      raise "Unsupported provider #{provider}"
+    when :parallels
+      # PROVIDER_MAC_PREFIXES[:parallels] + 3.times.map { '%02x' % rand(0..255) }.join
+      raise "Unsupported provider #{provider}"
+    when :hyper_v
+      # PROVIDER_MAC_PREFIXES[:hyper_v] + 3.times.map { '%02x' % rand(0..255) }.join
+    else
+      raise "Unsupported provider #{provider}"
+  end
+end

data/lib/vagrant-subutai/plugin.rb

@@ -0,0 +1,20 @@
+module VagrantSubutai
+    module Subutai
+        class Plugin < Vagrant.plugin(2)
+            name 'Subutai'
+            description <<-DESC
+              Vagrant Subutai CLI - executes Subutai scripts in target hosts
+            DESC
+
+            command(:subutai) do
+                require_relative 'command'
+                Command
+            end
+
+            config 'subutai_console' do
+              require_relative 'config'
+              Config
+            end
+        end
+    end
+end

data/lib/vagrant-subutai/rest.rb

@@ -0,0 +1,77 @@
+require 'net/https'
+require 'uri'
+require_relative '../vagrant-subutai'
+
+module VagrantSubutai
+  module Rest
+    class SubutaiConsole
+      # Subutai Console credentials username, password
+      # Subutai Console url
+      # login methods gets token
+      def self.token(url, username, password)
+        uri = URI.parse(url + SubutaiConsoleAPI::V1::TOKEN)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+        request = Net::HTTP::Post.new(uri.request_uri)
+        request.set_form_data('username' => username, 'password' => password)
+
+        # returns response
+        return http.request(request)
+      end
+
+      # Subutai Hub credentials email, password
+      # specify your peer_name
+      # peer_scope acceptable only like this "Public" : "Private"
+      def self.register(token, url, email, password, peer_name, peer_scope)
+        uri = URI.parse(url + SubutaiConsoleAPI::V1::REGISTER_HUB + token)
+        https = Net::HTTP.new(uri.host, uri.port)
+        https.use_ssl = true
+        https.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+        request = Net::HTTP::Post.new(uri.request_uri)
+        request.set_form_data({'email' => email, 'password' => password, 'peerName' => peer_name, 'peerScope' => peer_scope})
+
+        # returns response
+        return https.request(request)
+      end
+
+      # Approves Resource Host
+      def self.approve(token, url, id)
+        uri = URI.parse(url + SubutaiConsoleAPI::V1::APPROVE + "/#{id}/approve?sptoken?=" + token)
+        https = Net::HTTP.new(uri.host, uri.port)
+        https.use_ssl = true
+        https.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+        request = Net::HTTP::Post.new(uri.request_uri)
+
+        return https.request(request)
+      end
+
+      # Gets Finger print Subutai Console
+      def self.fingerprint(url)
+        uri = URI.parse(url + SubutaiConsoleAPI::V1::FINGERPRINT)
+        https = Net::HTTP.new(uri.host, uri.port)
+        https.use_ssl = true
+        https.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+        request = Net::HTTP::Get.new(uri.request_uri)
+
+        return https.request(request)
+      end
+
+      # Get Subutai Console RH requests
+      def self.requests(url, token)
+        uri = URI.parse(url + SubutaiConsoleAPI::V1::REQUESTS + token)
+        https = Net::HTTP.new(uri.host, uri.port)
+        https.use_ssl = true
+        https.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+        request = Net::HTTP::Get.new(uri.request_uri)
+
+        return https.request(request)
+      end
+    end
+  end
+end

data/lib/vagrant-subutai/rh_controller.rb

@@ -0,0 +1,32 @@
+require_relative '../vagrant-subutai'
+require 'json'
+
+module VagrantSubutai
+  class RhController
+
+    def all(token)
+      response = VagrantSubutai::Rest::SubutaiConsole.requests($SUBUTAI_CONSOLE_URL, token)
+      rhs = []
+
+      case response
+        when Net::HTTPOK
+          json = JSON.parse(response.body)
+
+          json.each do |data|
+            rh = VagrantSubutai::Models::Rh.new
+            rh.id = data['id']
+            rh.hostname = data['hostname']
+            rh.status = data['status']
+            rh.isConnected = data['isConnected']
+            rh.isManagement = data['isManagement']
+            rhs << rh
+          end
+        else
+          STDERR.puts "#{response.body}"
+          raise 'Can\'t get requests info from Subutai Console'
+      end
+
+      rhs
+    end
+  end
+end

data/lib/vagrant-subutai/subutai_commands.rb

@@ -0,0 +1,215 @@
+require_relative '../vagrant-subutai'
+require_relative 'command'
+require 'net/https'
+require 'io/console'
+require 'fileutils'
+require_relative 'rh_controller'
+
+module VagrantSubutai
+  class Commands < Vagrant.plugin('2', :command)
+
+    def initialize(arg, env)
+      super(arg, env)
+    end
+
+    # show snap logs
+    def log
+      ssh(base + SubutaiAgentCommand::LOG)
+    end
+
+    def base
+      env = SubutaiConfig.get(:SUBUTAI_ENV)
+
+      if env.nil?
+        SubutaiAgentCommand::BASE
+      else
+        if env.to_s == "prod"
+          SubutaiAgentCommand::BASE
+        else
+          "sudo /snap/bin/subutai-#{env.to_s}"
+        end
+      end
+    end
+
+    # info id
+    def info(arg)
+      with_target_vms(nil, single_target: true) do |vm|
+        vm.communicate.sudo("#{base} #{SubutaiAgentCommand::INFO} #{arg}") do |type, data|
+          if type == :stdout
+            result = data.split(/[\r\n]+/)
+            STDOUT.puts result.first
+            return result.first
+          end
+        end
+      end
+    end
+
+    # update Subutai rh or management
+    def update(name)
+      ssh(base + SubutaiAgentCommand::UPDATE + " #{name}")
+    end
+
+    # register Subutai Peer to Hub
+    def register(username, password)
+      username, password = get_input_token if username.nil? && password.nil?
+      response = VagrantSubutai::Rest::SubutaiConsole.token($SUBUTAI_CONSOLE_URL, username, password)
+
+      case response
+        when Net::HTTPOK
+          STDOUT.puts "Successfully you signed Subutai Console"
+          hub_email, hub_password, peer_name, peer_scope = get_input_register
+          response = VagrantSubutai::Rest::SubutaiConsole.register(response.body, $SUBUTAI_CONSOLE_URL, hub_email, hub_password, peer_name, peer_scope)
+
+          case response
+            when Net::HTTPOK
+              STDOUT.puts "You peer: \"#{peer_name}\" successfully registered to hub."
+            else
+              STDOUT.puts "Try again! #{response.body}\n"
+              register(username, password)
+          end
+        else
+          STDERR.puts "Try again! #{response.body}\n"
+          register(nil, nil)
+      end
+    end
+
+    # Add new RH to Peer
+    def add(peer_path, rh_name)
+      # TODO peer_path also be fixed(this path must work on all platforms)
+      peer_path = peer_path + "/#{VagrantSubutai::Subutai::RH_FOLDER_NAME}/#{rh_name}"
+
+      # create RH folder your_peer_path/RH/rh_name
+      unless File.exists?(peer_path)
+        FileUtils.mkdir_p(peer_path)
+
+        # 1. create RH
+        Dir.chdir(peer_path){
+          unless system(VagrantCommand::INIT + " " + $SUBUTAI_BOX_NAME)
+            raise "#{VagrantCommand::INIT} command failed."
+          end
+        }
+
+        # 2. vagrant up
+        Dir.chdir(peer_path){
+          unless system(VagrantCommand::RH_UP)
+            raise "#{VagrantCommand::RH_UP} command failed."
+          end
+        }
+
+        # 3. vagrant provision
+        Dir.chdir(peer_path){
+          unless system(VagrantCommand::PROVISION)
+            raise "#{VagrantCommand::PROVISION} command failed."
+          end
+        }
+
+        # 4. TODO set Subutai Console host and fingerprint in RH agent config
+        fingerprint = VagrantSubutai::Rest::SubutaiConsole.fingerprint($SUBUTAI_CONSOLE_URL).body
+        ip = info(VagrantCommand::ARG_IP_ADDR)
+
+        STDOUT.puts "Subutai Console(Peer)"
+        STDOUT.puts "ip: #{ip}"
+        STDOUT.puts "fingerprint: #{fingerprint}"
+
+        # 5. Check is RH request exist in Subutai Console
+        # then approve
+        rhs = []
+        # Get RH requests from Subutai Console
+        rhs = VagrantSubutai::RhController.new.all(get_token)
+
+        # Get RH id
+        id = nil
+        Dir.chdir(peer_path){
+          r, w = IO.pipe
+
+          pid = spawn(VagrantCommand::SUBUTAI_ID, :out => w)
+
+          w.close
+          id = r.read
+        }
+
+        # Check is this RH request exist in Subutai Console
+        found = rhs.detect {|rh| rh.id == id}
+
+        if found.nil?
+          raise 'RH not send request to Subutai Console for approve'
+        else
+          # TODO send REST call for approve RH to Subutai Console
+        end
+
+        STDOUT.puts "Your RH path: #{peer_path}"
+      end
+    end
+
+    # Show Subutai Console finger print
+    def fingerprint(url)
+      response = VagrantSubutai::Rest::SubutaiConsole.fingerprint(url)
+
+      case response
+        when Net::HTTPOK
+          STDOUT.puts response.body
+        else
+          STDOUT.puts "Try again! #{response.body}"
+      end
+    end
+
+    # Get Subutai console credentials from input
+    def get_input_token
+      STDOUT.puts "\nPlease enter credentials Subutai Console:\n"
+      STDOUT.puts "username: "
+      username = STDIN.gets.chomp
+      puts "password: "
+      password = STDIN.noecho(&:gets).chomp
+
+      [username, password]
+    end
+
+    # gets token
+    def get_token
+      username, password = get_input_token
+      response = VagrantSubutai::Rest::SubutaiConsole.token($SUBUTAI_CONSOLE_URL, username, password)
+
+      case response
+        when Net::HTTPOK
+          return response.body
+        else
+          get_token
+      end
+    end
+
+    # Get Hub credentials and peer info
+    def get_input_register
+      STDOUT.puts "\nRegister your peer to HUB:\n"
+
+      # Hub email
+      STDOUT.puts "Enter Hub email: "
+      hub_email = STDIN.gets.chomp
+
+      # Hub password
+      STDOUT.puts "Enter Hub password: "
+      hub_password = STDIN.noecho(&:gets).chomp
+
+      # Peer name
+      STDOUT.puts "Enter peer name: "
+      peer_name = STDIN.gets.chomp
+
+      # Peer scope
+      STDOUT.puts "1. Public"
+      STDOUT.puts "2. Private"
+      STDOUT.puts "Choose your peer scope (1 or 2): "
+      peer_scope = STDIN.gets.chomp.to_i
+
+      [hub_email, hub_password, peer_name, peer_scope]
+    end
+
+    def list(arg)
+      ssh(base + "#{SubutaiAgentCommand::LIST} #{arg}")
+    end
+
+    def ssh(command)
+      with_target_vms(nil, single_target: true) do |vm|
+        vm.action(:ssh_run, ssh_run_command: command, ssh_opts: {extra_args: ['-q']})
+      end
+    end
+  end
+end