vagrant-smartos-zones 0.0.1.pre.21

data/lib/vagrant/smartos/zones/util/checksum.rb

@@ -0,0 +1,22 @@
+require 'digest/md5'
+
+module Vagrant
+  module Smartos
+    module Zones
+      module Util
+        class Checksum
+          attr_reader :path, :checksum
+
+          def initialize(path, checksum)
+            @path = path
+            @checksum = checksum
+          end
+
+          def valid?
+            Digest::MD5.file(path) == checksum
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/smartos/zones/util/downloader.rb

@@ -0,0 +1,48 @@
+module Vagrant
+  module Smartos
+    module Zones
+      module Util
+        class Downloader
+          attr_reader :url, :utility
+
+          GET_PARAMS = {
+            'wget' => '-qO',
+            'curl' => '--silent -o'
+          }
+
+          READ_PARAMS = {
+            'wget' => '-qO-',
+            'curl' => '--silent'
+          }
+
+          def initialize(url)
+            @url = url
+            @utility = download_utility
+          end
+
+          def self.get(url, path)
+            new(url).get(path)
+          end
+
+          def get(path)
+            `#{utility} #{url} #{GET_PARAMS[utility]} #{path}`
+          end
+
+          def read
+            `#{utility} #{url} #{READ_PARAMS[utility]}`
+          end
+
+          private
+
+          def download_utility
+            if system('which wget >/dev/null')
+              'wget'
+            else
+              'curl'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/smartos/zones/util/global_zone/connection.rb

@@ -0,0 +1,192 @@
+require 'net/ssh'
+require 'stringio'
+require 'timeout'
+require 'vagrant/util/retryable'
+require 'vagrant/smartos/zones/util/global_zone/ssh_info'
+
+module Vagrant
+  module Smartos
+    module Zones
+      module Util
+        module GlobalZone
+          class Connection < Struct.new(:machine, :logger)
+            include Vagrant::Util::Retryable
+
+            CONNECTION_TIMEOUT = 60
+
+            # These are the exceptions that we retry because they represent
+            # errors that are generally fixed from a retry and don't
+            # necessarily represent immediate failure cases.
+            RETRYABLE_EXCEPTIONS = [
+              Errno::EACCES,
+              Errno::EADDRINUSE,
+              Errno::ECONNREFUSED,
+              Errno::ECONNRESET,
+              Errno::ENETUNREACH,
+              Errno::EHOSTUNREACH,
+              Net::SSH::Disconnect,
+              Timeout::Error
+            ]
+
+            class ErrorHandler < Struct.new(:error)
+              ERROR_MAPPING = {
+                # This happens on connect() for unknown reasons yet...
+                Errno::EACCES => Vagrant::Errors::SSHConnectEACCES,
+                # This happens if we continued to timeout when attempting to connect.
+                Errno::ETIMEDOUT => Vagrant::Errors::SSHConnectionTimeout,
+                Timeout::Error => Vagrant::Errors::SSHConnectionTimeout,
+                # This happens if authentication failed. We wrap the error in our own exception.
+                Net::SSH::AuthenticationFailed => Vagrant::Errors::SSHAuthenticationFailed,
+                # This happens if the remote server unexpectedly closes the
+                # connection. This is usually raised when SSH is running on the
+                # other side but can't properly setup a connection. This is
+                # usually a server-side issue.
+                Net::SSH::Disconnect => Vagrant::Errors::SSHDisconnected,
+                # This is raised if we failed to connect the max amount of times
+                Errno::ECONNREFUSED => Vagrant::Errors::SSHConnectionRefused,
+                # This is raised if we failed to connect the max number of times
+                # due to an ECONNRESET.
+                Errno::ECONNRESET => Vagrant::Errors::SSHConnectionReset,
+                # This is raised if we get an ICMP DestinationUnknown error.
+                Errno::EHOSTDOWN => Vagrant::Errors::SSHHostDown,
+                # This is raised if we can't work out how to route traffic.
+                Errno::EHOSTUNREACH => Vagrant::Errors::SSHNoRoute,
+                # This is raised if a private key type that Net-SSH doesn't support
+                # is used. Show a nicer error.
+                NotImplementedError => Vagrant::Errors::SSHKeyTypeNotSupported
+              }.freeze
+
+              def handle!
+                error_class = ERROR_MAPPING[error.class]
+                raise error_class if error_class
+              end
+            end
+
+            class SSHLogger
+              attr_reader :logger
+
+              def initialize
+                @io = StringIO.new
+                @logger = Logger.new(@io)
+              end
+
+              def to_s
+                @io.string
+              end
+            end
+
+            def with_connection
+              connect
+              yield @connection if block_given?
+            end
+
+            # rubocop:disable Metrics/MethodLength
+            def connect(**opts)
+              return @connection if connection_valid?
+
+              validate_ssh_info!
+              check_ssh_key_permissions
+
+              # Default some options
+              opts[:retries] = 5 unless opts.key?(:retries)
+
+              # Connect to SSH, giving it a few tries
+              connection = nil
+              begin
+                logger.info('Attempting SSH connection...')
+                connection = retryable(tries: opts[:retries], on: RETRYABLE_EXCEPTIONS) do
+                  Timeout.timeout(CONNECTION_TIMEOUT) do
+                    begin
+                      ssh_logger = SSHLogger.new
+
+                      # Setup logging for connections
+                      connect_opts = common_connect_opts.dup
+                      connect_opts[:logger] = ssh_logger.logger
+
+                      if ssh_info[:proxy_command]
+                        connect_opts[:proxy] = Net::SSH::Proxy::Command.new(ssh_info[:proxy_command])
+                      end
+
+                      logger.info('Attempting to connect to SSH...')
+                      logger.info("  - Host: #{ssh_info[:host]}")
+                      logger.info("  - Port: #{ssh_info[:port]}")
+                      logger.info("  - Username: #{ssh_info[:username]}")
+                      logger.info("  - Password? #{uses_password?}")
+                      logger.info("  - Key Path: #{ssh_info[:private_key_path]}")
+
+                      Net::SSH.start(ssh_info[:host], ssh_info[:username], connect_opts)
+                    ensure
+                      # Make sure we output the connection log
+                      logger.debug('== Net-SSH connection debug-level log START ==')
+                      logger.debug(ssh_logger.to_s)
+                      logger.debug('== Net-SSH connection debug-level log END ==')
+                    end
+                  end
+                end
+              rescue StandardError => e
+                ErrorHandler.new(e).handle!
+              end
+
+              @connection = connection
+            end
+
+            def ssh_info
+              @ssh_info ||= Util::GlobalZone::SSHInfo.new(machine.provider, machine.config, machine.env).to_hash
+            end
+
+            private
+
+            def check_ssh_key_permissions
+              ssh_info[:private_key_path].each do |path|
+                Vagrant::Util::SSH.check_key_permissions(Pathname.new(path))
+              end
+            end
+
+            def common_connect_opts
+              # Build the options we'll use to initiate the connection via Net::SSH
+              @common_connect_opts ||= {
+                auth_methods:          %w(none publickey hostbased password),
+                config:                false,
+                forward_agent:         ssh_info[:forward_agent],
+                keys:                  ssh_info[:private_key_path],
+                keys_only:             true,
+                paranoid:              false,
+                password:              ssh_info[:password],
+                port:                  ssh_info[:port],
+                timeout:               15,
+                user_known_hosts_file: [],
+                verbose:               :debug
+              }
+            end
+
+            def connection_valid?
+              return false unless @connection
+              return false if @connection.closed?
+
+              # There is a chance that the socket is closed despite us checking
+              # 'closed?' above. To test this we need to send data through the
+              # socket.
+              begin
+                @connection.exec!('')
+                true
+              rescue StandardError => e
+                logger.info('Connection errored, not re-using. Will reconnect.')
+                logger.debug(e.inspect)
+                @connection = nil
+                false
+              end
+            end
+
+            def uses_password?
+              !!ssh_info[:password]
+            end
+
+            def validate_ssh_info!
+              raise Vagrant::Errors::SSHNotReady if ssh_info.nil?
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/smartos/zones/util/global_zone/helper.rb

@@ -0,0 +1,33 @@
+module Vagrant
+  module Smartos
+    module Zones
+      module Util
+        module GlobalZone
+          module Helper
+            def self.included(klass)
+              klass.send(:extend, ClassHelpers)
+            end
+
+            def sudo
+              machine.config.smartos.suexec_cmd
+            end
+
+            def with_gz(command, options = {})
+              machine.communicate.gz_execute(command, options) do |_type, output|
+                yield output if block_given?
+              end
+            end
+          end
+
+          module ClassHelpers
+            def with_gz(machine, command, options = {})
+              machine.communicate.gz_execute(command, options) do |_type, output|
+                yield output if block_given?
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/smartos/zones/util/global_zone/ssh_info.rb

@@ -0,0 +1,85 @@
+module Vagrant
+  module Smartos
+    module Zones
+      module Util
+        module GlobalZone
+          class SSHInfo < Struct.new(:provider, :config, :env)
+            def forward_agent
+              config.ssh.forward_agent
+            end
+
+            def forward_x11
+              config.ssh.forward_x11
+            end
+
+            def host
+              return config.ssh.host if config.ssh.host
+              return ssh_info[:host] if ssh_info[:host]
+              config.ssh.default.host
+            end
+
+            def password
+              config.ssh.password
+            end
+
+            def port
+              port_forward[2]
+            end
+
+            def private_key_paths
+              return [] if password
+
+              @paths ||= [].tap do |paths|
+                paths << config.ssh.private_key_path
+                paths << config.ssh.default.private_key_path
+                paths << env.default_private_key_path
+              end.compact.map do |path|
+                File.expand_path(path, env.root_path)
+              end
+            end
+
+            def proxy_command
+              config.ssh.proxy_command if config.ssh.proxy_command
+            end
+
+            def username
+              return config.ssh.password if config.ssh.password
+              return ssh_info[:username] if ssh_info[:username]
+              config.ssh.default.username
+            end
+
+            # rubocop:disable Metrics/MethodLength
+            def to_hash
+              # From machine#ssh_info, if provider ssh_info is nil,
+              # machine is not ready for SSH.
+              return nil if ssh_info.nil?
+
+              {
+                host: host,
+                port: port,
+                private_key_path: private_key_paths,
+                username: username,
+                password: password,
+                proxy_command: proxy_command,
+                forward_agent: forward_agent,
+                forward_x11: forward_x11
+              }.delete_if { |_k, v| v.nil? }
+            end
+
+            private
+
+            def ssh_info
+              @ssh_info ||= provider.ssh_info
+            end
+
+            def port_forward
+              @port_forward ||= provider.driver.read_forwarded_ports.find do |fw|
+                fw[1] == 'gz_ssh'
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/smartos/zones/util/platform_images.rb

@@ -0,0 +1,132 @@
+require 'vagrant/smartos/zones/util/checksum'
+require 'vagrant/smartos/zones/util/downloader'
+require 'vagrant/util/downloader'
+
+module Vagrant
+  module Smartos
+    module Zones
+      module Util
+        class PlatformImages
+          attr_reader :env, :image, :machine
+
+          def initialize(env, machine = nil)
+            @env = env
+            @machine = machine
+            setup_smartos_directories
+          end
+
+          def get_platform_image(image)
+            @image = image
+            @image = latest_remote_or_current_image if image == 'latest'
+            install(image)
+            platform_image_path
+          end
+
+          def install(image)
+            @image = image
+            @image = latest_remote_or_current_image if image == 'latest'
+            if ::File.exist?(platform_image_path) && valid?
+              ui.info "SmartOS platform image #{image} exists"
+            else
+              download_checksum_file
+              download_platform_image
+            end
+          end
+
+          def list
+            ui.info(images.join("\n"), prefix: false)
+          end
+
+          def latest
+            latest_html = Zones::Util::Downloader.new(platform_image_latest_url).read
+            latest = latest_html.match(/(\d{8}T\d{6}Z)/)
+            return unless latest
+            latest[1]
+          end
+
+          protected
+
+          def setup_smartos_directories
+            env.setup_home_path if env.respond_to?(:setup_home_path)
+            FileUtils.mkdir_p(images_dir)
+            FileUtils.mkdir_p(checksums_dir)
+          end
+
+          def download_checksum_file
+            return if machine && machine.config.global_zone.platform_image_url
+            ui.info "Downloading checksums for SmartOS platform image #{image}"
+            Zones::Util::Downloader.get(platform_image_checksum_url, platform_image_checksum_path)
+          end
+
+          def download_platform_image
+            ui.info "Downloading SmartOS platform image #{image}"
+            Vagrant::Util::Downloader.new(platform_image_url, platform_image_path, ui: ui).download!
+          end
+
+          private
+
+          def ui
+            env.respond_to?(:ui) ? env.ui : env[:ui]
+          end
+
+          def home_path
+            env.respond_to?(:home_path) ? env.home_path : env[:home_path]
+          end
+
+          def valid?
+            return true if machine && machine.config.global_zone.platform_image_url
+            checksums = ::File.read(platform_image_checksum_path).split("\n")
+            iso_checksum = checksums.grep(/\.iso/).first.match(/^[^\s]+/).to_s
+            Checksum.new(platform_image_path, iso_checksum).valid?
+          end
+
+          def images
+            Dir[images_dir.join('*')].map do |f|
+              File.basename(f, '.iso')
+            end.sort
+          end
+
+          def images_dir
+            home_path.join('smartos', 'platform_images')
+          end
+
+          def checksums_dir
+            home_path.join('smartos', 'checksums')
+          end
+
+          def latest_remote_or_current_image
+            return latest if latest
+            ui.info 'Unable to read remote latest platform image, using local'
+            images.last
+          end
+
+          def platform_image_root
+            'https://us-east.manta.joyent.com'
+          end
+
+          def platform_image_path
+            images_dir.join("#{image}.iso")
+          end
+
+          def platform_image_url
+            return machine.config.global_zone.platform_image_url if machine &&
+              machine.config.global_zone.platform_image_url
+            "#{platform_image_root}/Joyent_Dev/public/SmartOS/#{image}/smartos-#{image}.iso"
+          end
+
+          def platform_image_latest_url
+            "#{platform_image_root}/Joyent_Dev/public/SmartOS/latest.html"
+          end
+
+          def platform_image_checksum_path
+            checksums_dir.join("#{image}.txt")
+          end
+
+          def platform_image_checksum_url
+            "#{platform_image_root}/Joyent_Dev/public/SmartOS/#{image}/md5sums.txt"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/smartos/zones/util/public_key.rb

@@ -0,0 +1,14 @@
+module Vagrant
+  module Smartos
+    module Zones
+      module Util
+        class PublicKey
+          # rubocop:disable Metrics/LineLength
+          def to_s
+            'ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEA6NF8iallvQVp22WDkTkyrtvp9eWW6A8YVr+kz4TjGYe7gHzIw+niNltGEFHzD8+v1I2YJ6oXevct1YeS0o9HZyN1Q9qgCgzUFtdOKLv6IedplqoPkcmF0aYet2PkEDo3MlTBckFXPITAMzF8dJSIFo9D8HfdOV0IAdx4O7PtixWKn5y2hMNG0zQPyUecp4pzC6kivAIhyfHilFR61RGL+GPXQ2MWZWFYbAGjyiYJnAmCP3NOTd0jMZEnDkbUvxhMmBYSdETk1rRgm+R4LOzFUGaHqHDLKLX+FIPKcF96hrucXzcWyLbIbEgE98OHlnVYCzRdK8jlqm8tehUc9c9WhQ== vagrant insecure public key'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/smartos/zones/util/snapshots.rb

@@ -0,0 +1,63 @@
+require 'vagrant/smartos/zones/models/snapshot'
+
+module Vagrant
+  module Smartos
+    module Zones
+      module Util
+        class Snapshots
+          include GlobalZone::Helper
+
+          attr_reader :machine, :zonename
+
+          def initialize(machine, zonename)
+            @machine = machine
+            @zonename = zonename
+          end
+
+          def run(action, snapshot = nil)
+            send action, snapshot
+          end
+
+          def list(_snapshot)
+            Models::Snapshot.all(zone).tap do |snapshots|
+              sns = snapshots.map do |snapshot|
+                [snapshot.name.ljust(12), snapshot.created_at.to_s.ljust(21),
+                 snapshot.space_used.to_s.rjust(6), snapshot.zone.name].join(' ')
+              end
+              machine.ui.info(I18n.t('vagrant.smartos.zones.commands.zones.snapshot.list',
+                                     snapshots: sns.join("\n")), prefix: false)
+            end
+          end
+
+          def create(name)
+            machine.ui.info(I18n.t('vagrant.smartos.zones.commands.zones.snapshot.create',
+                                   name: name), prefix: false)
+            Models::Snapshot.create(name, zone)
+          end
+
+          def destroy(name)
+            Models::Snapshot.find(name, zone).tap do |snapshot|
+              machine.ui.info(I18n.t('vagrant.smartos.zones.commands.zones.snapshot.destroy',
+                                     name: snapshot.name), prefix: false)
+              snapshot.destroy
+            end
+          end
+
+          def rollback(name)
+            Models::Snapshot.find(name, zone).tap do |snapshot|
+              machine.ui.info(I18n.t('vagrant.smartos.zones.commands.zones.snapshot.rollback',
+                                     zonename: zone.name, name: snapshot.name), prefix: false)
+              snapshot.rollback
+            end
+          end
+
+          private
+
+          def zone
+            @zone ||= Models::Zone.find(machine, zonename)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/smartos/zones/util/zone_group.rb

@@ -0,0 +1,34 @@
+require 'vagrant/smartos/zones/models/zone_group'
+require 'vagrant/smartos/zones/util/global_zone/helper'
+
+module Vagrant
+  module Smartos
+    module Zones
+      module Util
+        class ZoneGroup
+          include GlobalZone::Helper
+
+          attr_reader :machine, :zone
+
+          def initialize(machine, zone)
+            @machine = machine
+            @zone = zone
+          end
+
+          def find(group)
+            Models::ZoneGroup.new.tap do |g|
+              g.name = group
+              with_gz("#{sudo} zlogin #{zone.uuid} gid -g #{group}") do |_type, output|
+                g.gid = output.chomp
+              end
+            end
+          end
+
+          def create(group)
+            zone.zlogin("groupadd #{group}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/smartos/zones/util/zone_info.rb

@@ -0,0 +1,72 @@
+require 'vagrant/smartos/zones/models/zone'
+require 'vagrant/smartos/zones/util/global_zone/helper'
+require 'vagrant/smartos/zones/util/zone_group'
+require 'vagrant/smartos/zones/util/zone_json'
+require 'vagrant/smartos/zones/util/zone_project'
+require 'vagrant/smartos/zones/util/zone_user'
+
+module Vagrant
+  module Smartos
+    module Zones
+      module Util
+        class ZoneInfo
+          include GlobalZone::Helper
+
+          attr_reader :machine
+
+          ROOT_PASSWORD = '\$5\$90x8mAeX\$SKKNEjeztV.ruPBNf/E5y3xqGkwDv9A5KNP2S89GuB.'
+          VAGRANT_PASSWORD = '\$5\$UzQ1rHU/\$o67DYOyHOOabzJt.6DwgZP2qCGoAO7aVel2bgkuIwL7'
+
+          def initialize(machine)
+            @machine = machine
+          end
+
+          def create(name)
+            machine.ui.info "Creating zone #{machine.config.zone.name} with image #{machine.config.zone.image}"
+            with_gz("echo '#{zone_json}' | #{sudo} vmadm create")
+            with_zone(name) do |zone|
+              create_zone_users(zone)
+            end
+          end
+
+          def update(name)
+            with_zone(name) do |zone|
+              machine.ui.info "Updating zone #{name}..."
+              with_gz("echo '#{zone_json}' | #{sudo} vmadm update #{zone.uuid}")
+            end
+          end
+
+          private
+
+          def create_zone_users(zone)
+            create_zone_vagrant_user(zone)
+            configure_zone_passwords(zone)
+          end
+
+          def create_zone_vagrant_user(zone)
+            Util::ZoneGroup.new(machine, zone).create('vagrant')
+            Util::ZoneUser.new(machine, zone).create('vagrant', 'vagrant', 'Primary Administrator')
+            Util::ZoneProject.new(machine, zone).create('vagrant', %w(vagrant), 'Vagrant')
+          end
+
+          def configure_zone_passwords(zone)
+            overwrite_password(zone, 'root', ROOT_PASSWORD, '16151')
+            overwrite_password(zone, 'vagrant', VAGRANT_PASSWORD, '16158')
+          end
+
+          def overwrite_password(zone, user, pw, ts)
+            zone.zlogin("sed -i -e \\'s@#{user}:.*@#{user}:#{pw}:#{ts}::::::@\\' /etc/shadow")
+          end
+
+          def zone_json
+            Util::ZoneJson.new(machine).to_json
+          end
+
+          def with_zone(name)
+            Models::Zone.find(machine, name).tap { |zone| yield zone }
+          end
+        end
+      end
+    end
+  end
+end