vagrant-subutai 1.0.3 → 1.1.0

data/lib/vagrant-subutai/rest/subutai_console.rb

@@ -0,0 +1,189 @@
+require 'net/https'
+require 'uri'
+require_relative '../../vagrant-subutai'
+require 'mime/types'
+require 'json'
+
+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 + Configs::SubutaiConsoleAPI::V1::TOKEN)
+        https = Net::HTTP.new(uri.host, uri.port)
+        https.use_ssl = true
+        https.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        https.read_timeout = 3600 # an hour
+
+        request = Net::HTTP::Post.new(uri.request_uri)
+        request.set_form_data('username' => username, 'password' => password)
+
+        https.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 + Configs::SubutaiConsoleAPI::V1::REGISTER_HUB + token)
+        https = Net::HTTP.new(uri.host, uri.port)
+        https.use_ssl = true
+        https.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        https.read_timeout = 3600 # an hour
+
+        request = Net::HTTP::Post.new(uri.request_uri)
+        request.set_form_data({'email' => email, 'password' => password, 'peerName' => peer_name, 'peerScope' => peer_scope})
+
+        https.request(request)
+      end
+
+      # Approves Resource Host
+      def self.approve(token, url, id)
+        uri = URI.parse(url + Configs::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
+        https.read_timeout = 3600 # an hour
+
+        request = Net::HTTP::Post.new(uri.request_uri)
+
+        https.request(request)
+      end
+
+      # Gets Finger print Subutai Console
+      def self.fingerprint(url)
+        uri = URI.parse(url + Configs::SubutaiConsoleAPI::V1::FINGERPRINT)
+        https = Net::HTTP.new(uri.host, uri.port)
+        https.use_ssl = true
+        https.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        https.read_timeout = 3600 # an hour
+
+        request = Net::HTTP::Get.new(uri.request_uri)
+
+        response = https.request(request)
+
+        case response
+          when Net::HTTPOK
+            response.body
+          else
+            raise "Try again! #{response.body}"
+        end
+      end
+
+      # Get Subutai Console RH requests
+      # method GET
+      def self.requests(url, token)
+        uri = URI.parse(url + Configs::SubutaiConsoleAPI::V1::REQUESTS + token)
+        https = Net::HTTP.new(uri.host, uri.port)
+        https.use_ssl = true
+        https.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        https.read_timeout = 3600 # an hour
+
+        request = Net::HTTP::Get.new(uri.request_uri)
+
+        https.request(request)
+      end
+
+      # Creates Environment
+      # method POST
+      def self.environment(url, token, params)
+        uri = URI.parse(url + Configs::SubutaiConsoleAPI::V1::ENVIRONMENT + token)
+        https = Net::HTTP.new(uri.host, uri.port)
+        https.use_ssl = true
+        https.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        https.read_timeout = 21600 # 6 hours
+
+        request = Net::HTTP::Post.new(uri.request_uri)
+        request.set_form_data({'topology' => params})
+
+        https.request(request)
+      end
+
+      # Gets Peer Os resources (disk, ram and cpu)
+      # method GET
+      def self.resource(url, token)
+        uri = URI.parse(url + Configs::SubutaiConsoleAPI::V1::RESOURCES + token)
+        https = Net::HTTP.new(uri.host, uri.port)
+        https.use_ssl = true
+        https.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        https.read_timeout = 3600 # an hour
+
+        request = Net::HTTP::Get.new(uri.request_uri)
+
+        https.request(request)
+      end
+
+      # List Environments
+      # method GET
+      def self.environments(url, token)
+        uri = URI.parse(url + Configs::SubutaiConsoleAPI::V1::ENVIRONMENTS + token)
+        https = Net::HTTP.new(uri.host, uri.port)
+        https.use_ssl = true
+        https.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        https.read_timeout = 3600 # an hour
+
+        request = Net::HTTP::Get.new(uri.request_uri)
+
+        https.request(request)
+      end
+
+      # Sends command to Subutai Console
+      # method POST
+      def self.command(cmd, hostId, path, timeOut, url, token)
+        uri = URI.parse(url + Configs::SubutaiConsoleAPI::COMMAND + token)
+        https = Net::HTTP.new(uri.host, uri.port)
+        https.use_ssl = true
+        https.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        https.read_timeout = 21600 # 6 hours
+
+        request = Net::HTTP::Post.new(uri.request_uri)
+        request.set_form_data({'command' => cmd, 'hostId' => hostId, 'path' => path, 'timeOut' => timeOut})
+
+        https.request(request)
+      end
+
+      # Gives logs of Blueprint Environment builds
+      # method GET
+      def self.log(url, token, tracker_id)
+        uri = URI.parse(url + Configs::SubutaiConsoleAPI::V1::LOG + "#{tracker_id}?sptoken=#{token}")
+        https = Net::HTTP.new(uri.host, uri.port)
+        https.use_ssl = true
+        https.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        https.read_timeout = 21600 # 6 hours
+
+        request = Net::HTTP::Get.new(uri.request_uri)
+
+        https.request(request)
+      end
+
+      # Add domain to Environment
+      def self.domain(url, token, env_id, domain)
+        uri = URI.parse("#{url}#{Configs::SubutaiConsoleAPI::V1::DOMAIN}#{env_id}/domains?sptoken=#{token}")
+        https = Net::HTTP.new(uri.host, uri.port)
+        https.use_ssl = true
+        https.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        https.read_timeout = 3600 # an hour
+
+        request = Net::HTTP::Post.new(uri.request_uri)
+        request.set_form([['file', ''], ['hostName', domain], ['strategy', 'NONE']], 'multipart/form-data')
+
+        https.request(request)
+      end
+
+      # Add port to container
+      def self.port(url, token, env_id, cont_id, port)
+        uri = URI.parse("#{url}#{Configs::SubutaiConsoleAPI::V1::DOMAIN}#{env_id}/containers/#{cont_id}/domainnport?state=true&port=#{port}&sptoken=#{token}")
+        https = Net::HTTP.new(uri.host, uri.port)
+        https.use_ssl = true
+        https.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        https.read_timeout = 3600 # an hour
+
+        request = Net::HTTP::Put.new(uri.request_uri)
+
+        https.request(request)
+      end
+    end
+  end
+end

data/lib/vagrant-subutai/subutai_commands.rb

@@ -1,9 +1,7 @@
 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)
@@ -14,17 +12,17 @@ module VagrantSubutai
 
     # show snap logs
     def log
-      ssh(base + SubutaiAgentCommand::LOG)
+      ssh(base + Configs::SubutaiAgentCommand::LOG)
     end
 
     def base
       env = SubutaiConfig.get(:SUBUTAI_ENV)
 
       if env.nil?
-        SubutaiAgentCommand::BASE
+        Configs::SubutaiAgentCommand::BASE
       else
-        if env.to_s == "prod"
-          SubutaiAgentCommand::BASE
+        if env.to_s == 'prod'
+          Configs::SubutaiAgentCommand::BASE
         else
           "sudo /snap/bin/subutai-#{env.to_s}"
         end
@@ -34,10 +32,9 @@ module VagrantSubutai
     # info id
     def info(arg)
       with_target_vms(nil, single_target: true) do |vm|
-        vm.communicate.sudo("#{base} #{SubutaiAgentCommand::INFO} #{arg}") do |type, data|
+        vm.communicate.sudo("#{base} #{Configs::SubutaiAgentCommand::INFO} #{arg}") do |type, data|
           if type == :stdout
             result = data.split(/[\r\n]+/)
-            STDOUT.puts result.first
             return result.first
           end
         end
@@ -46,164 +43,295 @@ module VagrantSubutai
 
     # update Subutai rh or management
     def update(name)
-      ssh(base + SubutaiAgentCommand::UPDATE + " #{name}")
+      ssh(base + Configs::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)
+    # checks The Peer Os registered or not registered to Bazaar
+    def registered?(url)
+      fingerprint = Rest::SubutaiConsole.fingerprint(url)
+      response = Rest::Bazaar.registered(fingerprint)
 
       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
+          return true
+        when Net::HTTPNotFound
+          return false
         else
-          STDERR.puts "Try again! #{response.body}\n"
-          register(nil, nil)
+          Put.error response.body
+          Put.error response.message
+          exit
       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}"
+    # register Subutai Peer Os to Bazaar by username and password
+    def register(username, password, url)
+      if registered?(url)
+        Put.warn "\nThe Peer Os already registered to Bazaar.\n"
+      else
+        username, password = get_input_token if username.nil? && password.nil?
+        response = Rest::SubutaiConsole.token(url, username, password)
+
+        case response
+          when Net::HTTPOK
+            hub_email, hub_password, peer_name, peer_scope = get_input_register
+            peer_scope = peer_scope == 1 ? 'Public':'Private'
+            response = Rest::SubutaiConsole.register(response.body, url, hub_email, hub_password, peer_name, peer_scope)
+
+            case response
+              when Net::HTTPOK
+                Put.success response.body
+                Put.success "\"#{peer_name}\" successfully registered to Bazaar."
+              else
+                Put.error "Error: #{response.body}\n"
+                register(username, password, url)
+            end
+          else
+            Put.error "Error: #{response.body}\n"
+            register(nil, nil, url)
+        end
+      end
+    end
 
-      # create RH folder your_peer_path/RH/rh_name
-      unless File.exists?(peer_path)
-        FileUtils.mkdir_p(peer_path)
+    # register Subutai Peer Os to Bazaar by token
+    def register_by_token(token, url)
+      hub_email, hub_password, peer_name, peer_scope = get_input_register
+      response = Rest::SubutaiConsole.register(token, url, hub_email, hub_password, peer_name, peer_scope)
 
-        # 1. create RH
-        Dir.chdir(peer_path){
-          unless system(VagrantCommand::INIT + " " + $SUBUTAI_BOX_NAME)
-            raise "#{VagrantCommand::INIT} command failed."
-          end
-        }
+      case response
+        when Net::HTTPOK
+          Put.success response.body
+          Put.success "\"#{peer_name}\" successfully registered to Bazaar."
+          [hub_email, hub_password]
+        else
+          Put.error "Error: #{response.body}\n"
+          register_by_token(token, url)
+      end
+    end
 
-        # 2. vagrant up
-        Dir.chdir(peer_path){
-          unless system(VagrantCommand::RH_UP)
-            raise "#{VagrantCommand::RH_UP} command failed."
-          end
-        }
+    # Show Subutai Console finger print
+    def fingerprint(url)
+      peer_id = Rest::SubutaiConsole.fingerprint(url)
+      Put.info peer_id
+    end
 
-        # 3. vagrant provision
-        Dir.chdir(peer_path){
-          unless system(VagrantCommand::PROVISION)
-            raise "#{VagrantCommand::PROVISION} command failed."
-          end
-        }
+    # Get Subutai Peer Os credentials from input
+    def get_input_token
+      password = nil
+      username = nil
 
-        # 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)
+      if SubutaiConfig.get(:SUBUTAI_USERNAME).nil?
+        Put.warn "\nPlease enter credentials Subutai Peer Os:\n"
+        Put.info "\nusername: "
+        username = STDIN.gets.chomp
+      else
+        username = SubutaiConfig.get(:SUBUTAI_USERNAME)
+      end
 
-        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)
+      if SubutaiConfig.get(:SUBUTAI_PASSWORD).nil?
+        begin
+          Put.info "\npassword: "
+          password = STDIN.noecho(&:gets).chomp
+        rescue Errno::EBADF
+          Put.warn "\nStdin doesn't support echo less input. Stdin can't hide password\n"
+          password = STDIN.gets
+        end
+      else
+        password = SubutaiConfig.get(:SUBUTAI_PASSWORD)
+      end
 
-        # Get RH id
-        id = nil
-        Dir.chdir(peer_path){
-          r, w = IO.pipe
+      [username, password]
+    end
 
-          pid = spawn(VagrantCommand::SUBUTAI_ID, :out => w)
+    # Get Bazaar credentials from input
+    def get_input_login
 
-          w.close
-          id = r.read
-        }
+      email = nil
+      password = nil
 
-        # Check is this RH request exist in Subutai Console
-        found = rhs.detect {|rh| rh.id == id}
+      if SubutaiConfig.get(:BAZAAR_EMAIL).nil?
+        # Bazaar email
+        Put.warn "\nPlease enter credentials Bazaar:\n"
+        Put.info "\nemail: "
+        email = STDIN.gets.chomp
+      else
+        email = SubutaiConfig.get(:BAZAAR_EMAIL)
+      end
 
-        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}"
+      if SubutaiConfig.get(:BAZAAR_PASSWORD).nil?
+        # Bazaar password
+        begin
+          Put.info "\nEnter Bazaar password: "
+          password = STDIN.noecho(&:gets).chomp
+        rescue Errno::EBADF
+          Put.warn "\nStdin doesn't support echo less input. Stdin can't hide password\n"
+          password = STDIN.gets
+        end
+      else
+        password = SubutaiConfig.get(:BAZAAR_PASSWORD)
       end
+
+      [email, password]
     end
 
-    # Show Subutai Console finger print
-    def fingerprint(url)
-      response = VagrantSubutai::Rest::SubutaiConsole.fingerprint(url)
+    # Get Bazaar credentials and peer info
+    def get_input_register
+      Put.warn "\nRegister your peer to Bazaar:\n"
 
-      case response
-        when Net::HTTPOK
-          STDOUT.puts response.body
-        else
-          STDOUT.puts "Try again! #{response.body}"
+      hub_password = nil
+      hub_email = nil
+
+      if SubutaiConfig.get(:BAZAAR_EMAIL).nil?
+        # Hub email
+        Put.info "\nEnter Bazaar email: "
+        hub_email = STDIN.gets.chomp
+      else
+        hub_email = SubutaiConfig.get(:BAZAAR_EMAIL)
+      end
+
+
+      if SubutaiConfig.get(:BAZAAR_PASSWORD).nil?
+        # Hub password
+        begin
+          Put.info "\nEnter Bazaar password: "
+          hub_password = STDIN.noecho(&:gets).chomp
+        rescue Errno::EBADF
+          Put.warn "\nStdin doesn't support echo less input. Stdin can't hide password\n"
+          hub_password = STDIN.gets
+        end
+      else
+        hub_password = SubutaiConfig.get(:BAZAAR_PASSWORD)
       end
+
+      # Peer name
+      peer_name = SubutaiConfig.get(:SUBUTAI_NAME)
+
+      peer_scope = SubutaiConfig.get(:SUBUTAI_SCOPE)
+
+      [hub_email, hub_password, peer_name, peer_scope]
     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
+    def list(arg)
+      ssh(base + "#{Configs::SubutaiAgentCommand::LIST} #{arg}")
+    end
 
-      [username, password]
+    def blueprint(url)
+      variable = VagrantSubutai::Blueprint::VariablesController.new(0, 0, nil)
+
+      resource = info('system')
+
+      if variable.validate && variable.check_quota?(resource)
+        mode = SubutaiConfig.get(:SUBUTAI_ENV_TYPE)
+
+        if mode.nil?
+          # check smart defaults
+          fingerprint = Rest::SubutaiConsole.fingerprint(url)
+          response = Rest::Bazaar.registered(fingerprint)
+
+          case response
+            when Net::HTTPOK
+              # [MODE] The blueprint provisioning via Bazaar
+              bazaar(url)
+            when Net::HTTPNotFound
+              # [MODE] blueprint provisioning via Peer Os (local)
+              peer(url, resource)
+            else
+              Put.error response.message
+              Put.error response.body
+          end
+        elsif mode == Configs::Blueprint::MODE::PEER
+          # [MODE] blueprint provisioning via Peer Os (local)
+          peer(url, resource)
+        elsif mode == Configs::Blueprint::MODE::BAZAAR
+          # [MODE] The blueprint provisioning via Bazaar
+          bazaar(url)
+        end
+      end
     end
 
-    # gets token
-    def get_token
-      username, password = get_input_token
-      response = VagrantSubutai::Rest::SubutaiConsole.token($SUBUTAI_CONSOLE_URL, username, password)
+    def peer(url, resource)
+      Put.success "\n--------------------------------------"
+      Put.success "| Blueprint provisioning via Peer Os |"
+      Put.success "--------------------------------------\n"
+
+      username = SubutaiConfig.get(:SUBUTAI_USERNAME)
+      password = SubutaiConfig.get(:SUBUTAI_PASSWORD)
+
+      username, password = get_input_token if username.nil? && password.nil?
+      response = Rest::SubutaiConsole.token(url, username, password)
 
       case response
         when Net::HTTPOK
-          return response.body
+          rh_id = info('id')
+          peer_id = Rest::SubutaiConsole.fingerprint(url)
+
+          env = Blueprint::EnvironmentController.new
+          env.check_free_quota(resource)
+          env.build(url, response.body, rh_id, peer_id, Configs::Blueprint::MODE::PEER)
         else
-          get_token
+          Put.error "Error: #{response.body}"
+          Put.warn "\n[WARNING] if you have a new PeerOS make sure you have to change the default UI console password. It’s default credentials are ‘admin’ / ‘secret’.\n"
       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
+    def bazaar(url)
+      Put.success "\n-------------------------------------"
+      Put.success "| Blueprint provisioning via Bazaar |"
+      Put.success "-------------------------------------\n"
+      
+      email = SubutaiConfig.get(:BAZAAR_EMAIL)
+      password = SubutaiConfig.get(:BAZAAR_PASSWORD)
+
+      # Register Peer Os to Bazaar
+      unless registered?(url)
+        username = SubutaiConfig.get(:SUBUTAI_USERNAME)
+        pwd = SubutaiConfig.get(:SUBUTAI_PASSWORD)
+
+        username, pwd = get_input_token if username.nil? && pwd.nil?
+        response = Rest::SubutaiConsole.token(url, username, pwd)
+
+        case response
+          when Net::HTTPOK
+            email, password = register_by_token(response.body, url)
+          else
+            Put.error response.body
+            Put.error response.message
+        end
+      end
 
-      # Peer name
-      STDOUT.puts "Enter peer name: "
-      peer_name = STDIN.gets.chomp
+      email, password = get_input_login if email.nil? && password.nil?
 
-      # 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
+      response = Rest::Bazaar.login(email, password)
 
-      [hub_email, hub_password, peer_name, peer_scope]
+      case response
+        when Net::HTTPOK
+          all_cookies = response.get_fields('set-cookie')
+          cookies_array = Array.new
+          all_cookies.each { | cookie |
+            cookies_array.push(cookie.split('; ')[0])
+          }
+          cookies = cookies_array.join('; ')
+
+          rh_id = info('id')
+          peer_id = Rest::SubutaiConsole.fingerprint(url)
+
+          env = Blueprint::EnvironmentController.new
+          env.build(url, cookies, rh_id, peer_id, Configs::Blueprint::MODE::BAZAAR)
+        else
+          Put.error response.body
+      end
     end
 
-    def list(arg)
-      ssh(base + "#{SubutaiAgentCommand::LIST} #{arg}")
+    # opens browser
+    def open(link)
+      if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
+        system "start #{link}"
+      elsif RbConfig::CONFIG['host_os'] =~ /darwin/
+        system "open #{link}"
+      elsif RbConfig::CONFIG['host_os'] =~ /linux|bsd/
+        system "xdg-open #{link}"
+      end
     end
 
     def ssh(command)