vagrant-turbo 0.0.1.pre-x86-mingw32

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9da0e1e6b667c0770942f47f7be4835b2b380420
+  data.tar.gz: 5a2763df19767646a53b4b4404f6bff7cd784bde
+SHA512:
+  metadata.gz: 455d00d19f379470967136760f379270202945004afc8ccec948400ef0d4ab2b1eab438d855599be3d2d5a036fdb86f7802d13ccb510d4ee1beff1c10e29575d
+  data.tar.gz: ab7c1e9fd36a6446e559a1024f4811b7381e17ff58584d50f240a4376cb8ab8f2a7944a429d021d6cc026f93782e293b6cb1e262dbdd50b55e6a921e312e3534

data/.gitignore

@@ -0,0 +1,15 @@
+# Bundler/Rubygems
+*.gem
+.bundle
+pkg/*
+tags
+Gemfile.lock
+
+# Vagrant
+.vagrant
+Vagrantfile
+images
+
+# RVM files for gemset/ruby setting
+.ruby-*
+.rvmrc

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/Gemfile

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+group :development do
+  gem "vagrant", git: "https://github.com/mitchellh/vagrant.git"
+end
+
+group :plugins do
+  gemspec
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Michael Kalygin
+
+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,50 @@
+# Vagrant::Turbo
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/vagrant/turbo`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'vagrant-turbo'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install vagrant-turbo
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+Build locally
+```
+gem build vagrant-turbo.gemspec
+```
+
+Run local build in Vagrant context
+```
+bundle exec <vagrant command>
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/vagrant-turbo. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,21 @@
+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"

data/lib/vagrant-turbo/cap/windows/turbo_install.rb

@@ -0,0 +1,19 @@
+module VagrantPlugins
+  module Turbo
+    module Cap
+      module Windows
+        module TurboInstall
+          INSTALLER_URL = "\"http://start.spoon.net/install/?&brand=turbo\""
+          INSTALLER_PATH = "\"$env:temp\\installer.exe\""
+
+          def self.turbo_install(machine)
+            # TODO: use Vagrant utility to download files
+            machine.communicate.sudo("(new-object System.Net.WebClient).DownloadFile(#{INSTALLER_URL}, #{INSTALLER_PATH})")
+            # Turbo installer may return non-zero code, when it is not really failed
+            machine.communicate.sudo("& #{INSTALLER_PATH} | Out-Null; exit 0")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-turbo/cap/windows/turbo_installed.rb

@@ -0,0 +1,14 @@
+module VagrantPlugins
+  module Turbo
+    module Cap
+      module Windows
+        module TurboInstalled
+          def self.turbo_installed(machine)
+            command = "if ((& turbo version) -Match 'Version: *') { exit 0 } else { exit 1 }"
+            machine.communicate.test(command, sudo: true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-turbo/cap/windows/winrm_get_quota.rb

@@ -0,0 +1,53 @@
+require 'rexml/document'
+
+module VagrantPlugins
+  module Turbo
+    module Cap
+      module Windows
+        class Quota
+          def initialize(name, limit, source)
+            @__name = name
+            @__limit = limit
+            @__source = source
+          end
+
+          def name
+            @__name
+          end
+
+          def is_group_policy
+            'gpo'.casecmp(@__source) == 0
+          end
+
+          def limit
+            @__limit
+          end
+        end
+
+        module WinrmGetQuota
+          def self.winrm_get_quota(machine, quota_name)
+            output = ''
+            machine.communicate.execute('winrm get winrm/config/Winrs -format:xml') do |type, data|
+              if type == :stdout
+                output << data
+              end
+            end
+            doc = REXML::Document.new(output)
+            quota_node = REXML::XPath.first(doc, "//cfg:Winrs/cfg:#{quota_name}")
+            if quota_node
+              limit = quota_node.text.to_i
+              source = quota_node.attribute('Source')
+              source_value = if source
+                               source.value
+                             else
+                               ''
+                             end
+              return Quota.new(quota_name, limit, source_value)
+            end
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-turbo/cap/windows/winrm_set_quota.rb

@@ -0,0 +1,13 @@
+module VagrantPlugins
+  module Turbo
+    module Cap
+      module Windows
+        module WinrmSetQuota
+          def self.winrm_set_quota(machine, quota_name, limit)
+            machine.communicate.sudo("winrm set winrm/config/winrs '@{#{quota_name}=\"#{limit}\"}'")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-turbo/client.rb

@@ -0,0 +1,155 @@
+module VagrantPlugins
+  module Turbo
+    class Client
+      def initialize(machine)
+        @machine = machine
+        @logger = Log4r::Logger.new('vagrant::provisioners::turbo::client')
+      end
+
+      def login(config)
+        @machine.ui.info(I18n.t('vagrant_turbo.login', username: config.username))
+        run_with_output("turbo login #{config.username} #{config.password} --format=json")
+      end
+
+      def import(config)
+        @machine.ui.info(I18n.t('vagrant_turbo.import_image', path: config.path))
+        command = "turbo import #{config.type}"
+        command << " --name=#{config.name}" if config.name
+        command << ' --overwrite' if config.overwrite
+        command << ' ' << config.path
+
+        @machine.ui.info(I18n.t('vagrant_turbo.execute_command', command: command))
+        run_with_output(command)
+      end
+
+      def run(config)
+        command = 'turbo run'
+        command << " --name=#{config.name}" if config.name
+        command << ' --temp' if config.temp
+        # HACK - list of images must be passed in quotes. Otherwise Vagrant will split the command.
+        command << ' ' << "\"#{config.images.join(',')}\""
+        command << " --using=\"#{config.using.join(',')}\"" if config.using.any?
+        command << " --isolate=#{config.isolate}" if config.isolate
+        command << " --mount \"#{config.script_dir}\"=\"#{config.script_dir}\"" if config.script_dir
+
+        if config.startup_file
+          startup_file = config.startup_file
+          startup_file = "c:#{startup_file}" if startup_file.start_with?("\\")
+          command << " --startup-file=\"#{startup_file}\""
+        end
+
+        command << ' --pull' if config.pull
+        command << ' --no-stream' if config.no_stream
+        command << ' --admin' if config.admin
+
+        command << " --trigger=\"#{config.trigger}\"" if config.trigger
+        command << " --vm=#{config.vm}" if config.vm
+        command << " --with-root=\"#{with_root}\"" if config.with_root
+
+        command << ' --attach' if config.attach
+        command << ' --detach' if config.detach
+        command << " --format=#{config.format}" if config.format
+        command << ' --diagnostic' if config.diagnostic
+
+        command << flat_with_prefix('--enable=', config.enable) if config.enable
+        command << flat_with_prefix('--disable=', config.disable) if config.disable
+        command << ' --disable-sync' if config.disable_sync
+        command << flat_with_prefix('--env=', config.env) if config.env
+        command << " --env-file=\"#{config.env_file}\"" if config.env_file
+
+        command << ' --private' if config.private
+        command << ' --public' if config.public
+        command << ' --enable-log-stream' if config.enable_log_stream
+        command << ' --enable-screencast' if config.enable_screencast
+        command << ' --enable-sync' if config.enable_sync
+
+        command << flat_with_prefix('--mount=', config.mount) if config.mount
+        command << ' --install' if config.install
+
+        command << " --network=#{config.network}" if config.network
+        command << flat_with_prefix('--hosts=', config.hosts) if config.hosts
+        command << flat_with_prefix('--link=', config.link) if config.link
+        command << flat_with_prefix('--route-add=', config.route_add) if config.route_add
+        command << flat_with_prefix('--route-block=', config.route_block) if config.route_block
+
+        @machine.ui.info(I18n.t('vagrant_turbo.execute_command', command: command))
+        run_with_output(command)
+      end
+
+      def shell(config)
+        with_pretty_print do |output|
+          @machine.communicate.execute("tsh \"#{config.path}\"") do |type, data|
+            output.append(type, data)
+          end
+        end
+      end
+
+      private
+
+      def flat_with_prefix(prefix, array)
+        args_with_prefix = array.map { |value| prefix + value }
+        ' ' << args_with_prefix.join(' ')
+      end
+
+      def run_with_output(command)
+        with_pretty_print do |output|
+          @machine.communicate.execute(command) do |type, data|
+            output.append(type, data)
+          end
+        end
+      end
+
+      def log_communication(type, data)
+        if [:stderr, :stdout].include?(type)
+          @logger.info(data)
+        end
+      end
+
+      def with_pretty_print
+        pretty_print = PrettyPrint.new(@machine, @logger)
+        yield pretty_print
+        pretty_print.flush
+      end
+    end
+
+    class PrettyPrint
+      def initialize(machine, logger)
+        @machine = machine
+        @logger = logger
+        @buffer = []
+      end
+
+      def append(type, output)
+        unless [:stderr, :stdout].include?(type)
+          return
+        end
+
+        @logger.info(output)
+
+        # Clear out the newline since we add one
+        line = output.chomp
+        return if line.empty?
+
+        # Remove progress marquee
+        return if '-\|/'.include?(line)
+
+        if line.length > 1
+          if @buffer
+            prefix = @buffer.join('')
+            line = prefix << line
+            @buffer.clear
+          end
+          @machine.ui.info(line)
+        else
+          @buffer << line
+        end
+      end
+
+      def flush
+        if @buffer
+          @machine.ui.info(@buffer.join(''))
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-turbo/config.rb

@@ -0,0 +1,395 @@
+require 'pathname'
+
+module VagrantPlugins
+  module Turbo
+    class ConfigUtils
+      def self.validate_path(path, machine, errors)
+        errors << I18n.t('vagrant_turbo.invalid_type', param: 'path', type: 'String') unless path.is_a?(String)
+        expanded_path = Pathname.new(path).expand_path(machine.env.root_path)
+        if expanded_path.file?
+          data = expanded_path.read(16)
+          if data && !data.valid_encoding?
+            errors << I18n.t(
+                'vagrant_turbo.invalid_encoding',
+                actual: data.encoding.to_s,
+                default: Encoding.default_external.to_s,
+                path: expanded_path.to_s)
+          end
+        else
+          errors << I18n.t('vagrant_turbo.path_invalid', path: expanded_path)
+        end
+      end
+    end
+
+    class Config < Vagrant.plugin('2', :config)
+      attr_accessor :max_memory_per_shell
+
+      def initialize
+        super
+
+        @max_memory_per_shell = UNSET_VALUE
+        @__command_names = []
+        @__commands = {}
+      end
+
+      def finalize!
+        @max_memory_per_shell = nil if @max_memory_per_shell == UNSET_VALUE
+
+        commands.each { |c| c.finalize! }
+      end
+
+      def validate(machine)
+        errors = _detected_errors
+
+        errors << I18n.t('vagrant_turbo.invalid_type', param: 'max_memory_per_shell', type: 'Integer') if max_memory_per_shell && !max_memory_per_shell.is_a?(Integer)
+
+        commands.each do |command|
+          command.validate(machine).each do |key, local_errors|
+            local_errors.select { |msg| msg != nil }.each do |msg|
+              errors << "#{key} => #{msg}"
+            end
+          end
+        end
+
+        {'turbo provisioner' => errors}
+      end
+
+      def commands
+        @__command_names.map { |name| @__commands[name] }
+      end
+
+      def login(name, **options, &block)
+        _add_command(name, LoginConfig, **options, &block)
+      end
+
+      def import(name, **options, &block)
+        _add_command(name, ImportConfig, **options, &block)
+      end
+
+      def run(name, **options, &block)
+        _add_command(name, RunConfig, **options, &block)
+      end
+
+      def shell(name, **options, &block)
+        _add_command(name, TurboShellConfig, **options, &block)
+      end
+
+      private
+
+      def _add_command(name, type, **_options, &block)
+        name_to_use = name || "__default_#{type.name}"
+        command = @__commands[name_to_use]
+        unless command
+          command = type.new
+          @__commands[name_to_use] = command
+          @__command_names << name_to_use
+        end
+
+        block.call(command) if block_given?
+        nil
+      end
+    end
+
+    class LoginConfig < Vagrant.plugin('2', :config)
+      attr_accessor :username
+      attr_accessor :password
+
+      def initialize
+        @username = UNSET_VALUE
+        @password = UNSET_VALUE
+      end
+
+      def validate(_machine)
+        errors = _detected_errors
+
+        # Check login and password
+        if username && !username.is_a?(String)
+          I18n.t('vagrant_turbo.invalid_type', param: 'username', type: 'String')
+        end
+
+        if password && password.is_a?(String)
+          I18n.t('vagrant_turbo.invalid_type', param: 'password', type: 'String')
+        end
+
+        errors << I18n.t('vagrant_turbo.login_required') if !username || !password
+
+        {'turbo login' => errors}
+      end
+
+      def finalize!
+        @username = nil if @username == UNSET_VALUE
+        @password = nil if @password == UNSET_VALUE
+      end
+    end
+
+    class ImportConfig < Vagrant.plugin('2', :config)
+      attr_accessor :name
+      attr_accessor :path
+      attr_accessor :type
+      attr_accessor :overwrite
+
+      def initialize
+        super
+        @path = UNSET_VALUE
+        @name = UNSET_VALUE
+        @type = UNSET_VALUE
+        @overwrite = UNSET_VALUE
+      end
+
+      def validate(_machine)
+      end
+
+      def finalize!
+        @name = nil if @name == UNSET_VALUE
+        @type = 'SVM' if @type == UNSET_VALUE
+        @overwrite = true if @overwrite == UNSET_VALUE
+      end
+    end
+
+    class RunConfig < Vagrant.plugin('2', :config)
+      attr_accessor :inline
+      attr_accessor :path
+      attr_accessor :script_dir
+      attr_accessor :powershell_args
+
+      attr_accessor :name
+      attr_accessor :temp
+      attr_accessor :images
+      attr_accessor :using
+      attr_accessor :isolate
+      attr_accessor :startup_file
+      attr_accessor :pull
+      attr_accessor :no_stream
+      attr_accessor :admin
+
+      attr_accessor :trigger
+      attr_accessor :vm
+      attr_accessor :with_root
+
+      attr_accessor :attach
+      attr_accessor :detach
+      attr_accessor :format
+      attr_accessor :diagnostic
+
+      attr_accessor :enable
+      attr_accessor :disable
+      attr_accessor :disable_sync
+      attr_accessor :env
+      attr_accessor :env_file
+
+      attr_accessor :private
+      attr_accessor :public
+      attr_accessor :enable_log_stream
+      attr_accessor :enable_screencast
+      attr_accessor :enable_sync
+
+      attr_accessor :mount
+      attr_accessor :install
+
+      attr_accessor :network
+      attr_accessor :hosts
+      attr_accessor :link
+      attr_accessor :route_add
+      attr_accessor :route_block
+
+      def initialize
+        @inline = UNSET_VALUE
+        @path = UNSET_VALUE
+        @script_dir = UNSET_VALUE
+        @powershell_args = UNSET_VALUE
+
+        @name = UNSET_VALUE
+        @temp = UNSET_VALUE
+        @images = UNSET_VALUE
+        @using = UNSET_VALUE
+        @isolate = UNSET_VALUE
+        @startup_file = UNSET_VALUE
+        @pull = UNSET_VALUE
+        @no_stream = UNSET_VALUE
+        @admin = UNSET_VALUE
+
+        @trigger = UNSET_VALUE
+        @vm = UNSET_VALUE
+        @with_root = UNSET_VALUE
+
+        @attach = UNSET_VALUE
+        @detach = UNSET_VALUE
+        @format = UNSET_VALUE
+        @diagnostic = UNSET_VALUE
+
+        @enable = UNSET_VALUE
+        @disable = UNSET_VALUE
+        @env = UNSET_VALUE
+        @env_file = UNSET_VALUE
+
+        @private = UNSET_VALUE
+        @public = UNSET_VALUE
+        @enable_log_stream = UNSET_VALUE
+        @enable_screencast = UNSET_VALUE
+        @enable_sync = UNSET_VALUE
+        @disable_sync = UNSET_VALUE
+
+        @mount = UNSET_VALUE
+        @install = UNSET_VALUE
+
+        @network = UNSET_VALUE
+        @hosts = UNSET_VALUE
+        @link = UNSET_VALUE
+        @route_add = UNSET_VALUE
+        @route_block = UNSET_VALUE
+      end
+
+      def validate(machine)
+        errors = _detected_errors
+
+        # Check script parameters
+        errors << require_string('inline', inline)
+        ConfigUtils.validate_path(path, machine, errors) if path
+        errors << I18n.t('vagrant_turbo.path_and_inline_set') if path && inline
+        errors << require_string('powershell_args', powershell_args)
+        errors << require_string('script_dir', script_dir)
+
+        # Check run parameters
+        errors << require_string('name', name)
+        errors << require_bool('temp', temp)
+        errors << require_array('images', images)
+        errors << require_array('using', using)
+        if isolate
+          if !isolate.is_a?(String)
+            errors << I18n.t('vagrant_turbo.invalid_type', param: 'isolate', type: 'String')
+          elsif !%w(full write-copy merge).include?(isolate.downcase)
+            errors << I18n.t('vagrant_turbo.invalid_parameter', param: 'isolate', values: 'full, write-copy, merge')
+          end
+        end
+        errors << require_string('startup_file', startup_file)
+        errors << require_bool('no_stream', no_stream)
+        errors << require_bool('admin', admin)
+        errors << require_bool('pull', pull)
+
+        errors << require_string('trigger', trigger)
+        errors << require_string('vm', vm)
+        errors << require_string('with_root', with_root)
+
+        errors << require_bool('detach', detach)
+        errors << require_bool('attach', attach)
+        errors << require_string('format', format)
+        errors << require_bool('diagnostic', diagnostic)
+
+        errors << require_array('enable', enable)
+        errors << require_array('disable', disable)
+        errors << require_array('env', env)
+        errors << require_string('env_file', env_file)
+
+        errors << require_bool('private', private)
+        errors << require_bool('public', public)
+        errors << require_bool('enable_log_stream', enable_log_stream)
+        errors << require_bool('enable_screencast', enable_screencast)
+        errors << require_bool('enable_sync', enable_sync)
+        errors << require_bool('disable_sync', disable_sync)
+
+        errors << require_array('mount', mount)
+        errors << require_bool('install', install)
+
+        errors << require_string('network', network)
+        errors << require_array('hosts', hosts)
+        errors << require_array('link', link)
+        errors << require_array('route_add', route_add)
+        errors << require_array('route_block', route_block)
+
+        errors << I18n.t('vagrant_turbo.startup_file_with_path_or_inline') if startup_file && (path || inline)
+
+        {'turbo run' => errors}
+      end
+
+      def finalize!
+        @inline = nil if @inline == UNSET_VALUE
+        @path = nil if @path == UNSET_VALUE
+        @script_dir = 'C:\\tmp\\vagrant-turbo' if @script_dir == UNSET_VALUE
+        @powershell_args = nil if @powershell_args == UNSET_VALUE
+
+        @name = nil if @name == UNSET_VALUE
+        @temp = false if @temp == UNSET_VALUE
+        @images = [] if @images == UNSET_VALUE
+        @using = [] if @using == UNSET_VALUE
+        @isolate = nil if @isolate == UNSET_VALUE
+        @startup_file = nil if @startup_file == UNSET_VALUE
+        @pull = false if @pull == UNSET_VALUE
+        @no_stream = false if @no_stream == UNSET_VALUE
+        @admin = false if @admin == UNSET_VALUE
+
+        @trigger = nil if @trigger == UNSET_VALUE
+        @vm = nil if @vm == UNSET_VALUE
+        @with_root = nil if @with_root == UNSET_VALUE
+
+        @detach = false if @detach == UNSET_VALUE
+        @attach = false if @attach == UNSET_VALUE
+        @format = nil if @format == UNSET_VALUE
+        @diagnostic = false if @diagnostic == UNSET_VALUE
+
+        @enable = [] if @enable == UNSET_VALUE
+        @disable = [] if @disable == UNSET_VALUE
+        @env = [] if @env == UNSET_VALUE
+        @env_file = nil if @env_file == UNSET_VALUE
+
+        @private = false if @private == UNSET_VALUE
+        @public = false if @public == UNSET_VALUE
+        @enable_log_stream = false if @enable_log_stream == UNSET_VALUE
+        @enable_screencast = false if @enable_screencast == UNSET_VALUE
+        @enable_sync = false if @enable_sync == UNSET_VALUE
+        @disable_sync = false if @disable_sync == UNSET_VALUE
+
+        @mount = [] if @mount == UNSET_VALUE
+        @install = false if @install == UNSET_VALUE
+
+        @network = nil if @network == UNSET_VALUE
+        @hosts = [] if @hosts == UNSET_VALUE
+        @link = [] if @link == UNSET_VALUE
+        @route_add = [] if @route_add == UNSET_VALUE
+        @route_block = [] if @route_block == UNSET_VALUE
+      end
+
+      private
+
+      def require_bool(param_name, value)
+        I18n.t('vagrant_turbo.invalid_type', param: param_name, type: 'Boolean') unless !!value == value
+      end
+
+      def require_string(param_name, value)
+        errors << I18n.t('vagrant_turbo.invalid_type', param: param_name, type: 'String') if value && !value.is_a?(String)
+      end
+
+      def require_array(param_name, value)
+        errors << I18n.t('vagrant_turbo.invalid_type', param: param_name, type: 'Array') if value && !value.is_a?(Array)
+      end
+    end
+
+    class TurboShellConfig < Vagrant.plugin('2', :config)
+      attr_accessor :inline
+      attr_accessor :path
+      attr_accessor :script_dir
+
+      def initialize
+        @inline = UNSET_VALUE
+        @path = UNSET_VALUE
+        @script_dir = UNSET_VALUE
+      end
+
+      def validate(machine)
+        errors = _detected_errors
+        errors << I18n.t('vagrant_turbo.invalid_type', param: 'inline', type: 'String') if inline && !inline.is_a?(String)
+        ConfigUtils.validate_path(path, machine, errors) if path
+
+        errors << I18n.t('vagrant_turbo.path_and_inline_set') if path && inline
+        errors << I18n.t('vagrant_turbo.path_and_inline_set') if path && inline
+
+        {'turbo shell' => errors}
+      end
+
+      def finalize!
+        @script_dir = 'C:\\tmp\\vagrant-turbo' if @script_dir == UNSET_VALUE
+        @path = nil if @path == UNSET_VALUE
+        @inline = nil if @inline == UNSET_VALUE
+      end
+    end
+  end
+end

data/lib/vagrant-turbo/installer.rb

@@ -0,0 +1,22 @@
+module VagrantPlugins
+  module Turbo
+    class Installer
+      def initialize(machine)
+        @machine = machine
+      end
+
+      def ensure_installed
+        @machine.ui.info(I18n.t('vagrant_turbo.check_install'))
+
+        unless @machine.guest.capability(:turbo_installed)
+          @machine.ui.info(I18n.t('vagrant_turbo.not_installed'))
+          @machine.guest.capability(:turbo_install)
+
+          unless @machine.guest.capability(:turbo_installed)
+            raise TurboError, :install_failed
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-turbo/plugin.rb

@@ -0,0 +1,42 @@
+require 'vagrant'
+
+module VagrantPlugins
+  module Turbo
+    class Plugin < Vagrant.plugin(2)
+      name 'turbo'
+      description <<-DESC
+      Provides support for Turbo
+      DESC
+
+      config(:turbo, :provisioner) do
+        require_relative 'config'
+        Config
+      end
+
+      guest_capability(:windows, :turbo_installed) do
+        require_relative 'cap/windows/turbo_installed'
+        Cap::Windows::TurboInstalled
+      end
+
+      guest_capability(:windows, :turbo_install) do
+        require_relative 'cap/windows/turbo_install'
+        Cap::Windows::TurboInstall
+      end
+
+      guest_capability(:windows, :winrm_get_quota) do
+        require_relative 'cap/windows/winrm_get_quota'
+        Cap::Windows::WinrmGetQuota
+      end
+
+      guest_capability(:windows, :winrm_set_quota) do
+        require_relative 'cap/windows/winrm_set_quota'
+        Cap::Windows::WinrmSetQuota
+      end
+
+      provisioner(:turbo) do
+        require_relative 'provisioner'
+        Provisioner
+      end
+    end
+  end
+end

data/lib/vagrant-turbo/provisioner.rb

@@ -0,0 +1,207 @@
+require 'log4r'
+require 'pathname'
+require 'tempfile'
+require_relative 'client'
+require_relative 'installer'
+require_relative 'config'
+
+module VagrantPlugins
+  module Turbo
+    class TurboError < Vagrant::Errors::VagrantError
+      error_namespace('vagrant_turbo')
+    end
+
+    class Provisioner < Vagrant.plugin(2, :provisioner)
+      def initialize(machine, config, client = nil, installer = nil)
+        super(machine, config)
+
+        @client = client || Client.new(machine)
+        @installer = installer || Installer.new(machine)
+        @logger = Log4r::Logger.new('vagrant::provisioners::turbo')
+      end
+
+      def provision
+        setup_max_memory_per_shell
+
+        @logger.info('Ensure turbo installed')
+        @installer.ensure_installed
+
+        config.commands.each do |command|
+          if command.is_a?(ImportConfig)
+            import(command)
+            next
+          end
+
+          if command.is_a?(LoginConfig)
+            login(command)
+            next
+          end
+
+          if command.is_a?(RunConfig)
+            run(command)
+            next
+          end
+
+          if command.is_a?(TurboShellConfig)
+            shell(command)
+          end
+        end
+      end
+
+      private
+
+      def setup_max_memory_per_shell
+        quota_name = 'MaxMemoryPerShellMB'
+        recommended_limit = 1024
+
+        machine.ui.info(I18n.t('vagrant_turbo.check_quota', quota_name: quota_name))
+        quota = machine.guest.capability(:winrm_get_quota, quota_name)
+        if quota
+          @logger.info("#{quota_name} was initially set to #{quota.limit}")
+
+          if config.max_memory_per_shell
+            if quota.is_group_policy && quota.limit != config.max_memory_per_shell
+              raise TurboError, :quota_protected_by_group_policy_increase_info
+            end
+            machine.guest.capability(:winrm_set_quota, quota_name, config.max_memory_per_shell)
+            machine.ui.info(I18n.t('vagrant_turbo.quota_set_to', quota_name: quota_name, quota_limit: config.max_memory_per_shell))
+          elsif quota.limit < recommended_limit
+            machine.ui.warn(I18n.t('vagrant_turbo.quota_below_recommended_limit', quota_name: quota_name, quota_limit: quota.limit, recommended_limit: recommended_limit))
+            if quota.is_group_policy
+              machine.ui.warn(I18n.t('vagrant_turbo.quota_protected_by_group_policy_increase_info'))
+            else
+              machine.ui.warn(I18n.t('vagrant_turbo.quota_increase_info', quota_name: quota_name, recommended_limit: recommended_limit))
+            end
+            machine.ui.warn(I18n.t('vagrant_turbo.small_quota_warning'))
+          end
+        else
+          @logger.info("Failed to get #{quota_name} quota limit")
+        end
+      end
+
+      def login (login_config)
+        @logger.info('Login to the hub')
+        @client.login(login_config)
+      end
+
+      def run(run_config)
+        run_config.startup_file = build_startup_file(run_config)
+        @client.run(run_config)
+      end
+
+      def import(import_config)
+        import_config.path = expand_guest_path(import_config.path)
+        @client.import(import_config)
+      end
+
+      def shell(shell_config)
+        with_script_file(shell_config) do |path|
+          machine.communicate.tap do |comm|
+            machine.ui.info(I18n.t('vagrant_turbo.running', script: shell_config.path || 'inline Turbo script'))
+            comm.upload(path, shell_config.script_dir)
+            shell_config.path = File.join(shell_config.script_dir, File.basename(path))
+            @client.shell(shell_config)
+          end
+        end
+      end
+
+      def build_startup_file(config)
+        machine.communicate.tap do |comm|
+          dir_to_use = expand_guest_path(config.script_dir)
+
+          # Make sure the remote path exists
+          comm.execute("mkdir '#{dir_to_use}'")
+
+          if config.path
+            file_to_upload = File.expand_path(config.path)
+
+            @logger.info("Uploading #{file_to_upload} to #{dir_to_use}")
+            comm.upload(file_to_upload, dir_to_use)
+
+            if File.extname(file_to_upload).casecmp('.ps1') == 0
+              # Hack create bat script to launch Powershell
+              launch_command = 'powershell'
+              if config.powershell_args
+                launch_command << ' -ExecutionPolicy Bypass' if config.powershell_args !~ /[-\/]ExecutionPolicy/i
+                launch_command << ' -OutputFormat Text' if config.powershell_args !~ /[-\/]OutputFormat/i
+                launch_command << ' ' << config.powershell_args
+              else
+                launch_command << ' -ExecutionPolicy Bypass -OutputFormat Text'
+              end
+              launch_command << " -File \"#{File.join(dir_to_use, File.basename(file_to_upload))}\""
+
+              return upload_startup_file(comm, dir_to_use, launch_command)
+            else
+              return File.join(dir_to_use, File.basename(config.path))
+            end
+          else
+            return upload_startup_file(comm, dir_to_use, config.inline)
+          end
+        end
+      end
+
+      def cleanup
+      end
+
+      def upload_startup_file(comm, guest_dir, *lines)
+        file_name = 'turbo-launch.bat'
+        startup_file = File.join(guest_dir, file_name)
+
+        @logger.info("Creating startup file #{startup_file}")
+        temp_file = Tempfile.new(file_name)
+        begin
+          temp_file.puts(lines)
+          temp_file.close
+          comm.upload(File.expand_path(temp_file.path), startup_file)
+        ensure
+          temp_file.close
+          temp_file.unlink
+        end
+
+        startup_file
+      end
+
+      # Expand the guest path if the guest has the capability
+      def expand_guest_path(destination)
+        if machine.guest.capability?(:shell_expand_guest_path)
+          machine.guest.capability(:shell_expand_guest_path, destination)
+        else
+          destination.to_s.gsub('/', "\\")
+        end
+      end
+
+      def with_script_file(config)
+        script = if config.path
+                   # Read the content of the script
+                   Pathname.new(config.path).expand_path(machine.env.root_path).read
+                 else
+                   # The script is just the inline code
+                   config.inline
+                 end
+
+        # Create temp file for the script
+        file = Tempfile.new(%w(vagrant-turbo .tsh))
+        file.binmode
+
+        begin
+          file.write(script)
+          file.fsync
+          file.close
+          yield file.path.gsub('/', "\\")
+        ensure
+          file.close
+          file.unlink
+        end
+      end
+
+      def handle_comm(type, data)
+        if [:stderr, :stdout].include?(type)
+          data = data.chomp
+          options = {:color => type == :stdout ? :green : :red}
+          return if data.empty? || !(data =~ /\||\\|\/|\-/).nil?
+          machine.ui.info(data, options)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-turbo/version.rb

@@ -0,0 +1,5 @@
+module VagrantPlugins
+  module Turbo
+    VERSION = '0.0.1.pre'
+  end
+end

data/lib/vagrant-turbo.rb

@@ -0,0 +1,18 @@
+require 'vagrant-turbo/plugin'
+
+module VagrantPlugins
+  module Turbo
+    LOCALES_PATH = 'locales/en.yml'
+
+    def self.root
+      File.expand_path '../..', __FILE__
+    end
+
+    def self.setup_locales
+      I18n.load_path << File.expand_path(LOCALES_PATH, root)
+      I18n.reload!
+    end
+
+    setup_locales
+  end
+end

data/locales/en.yml

@@ -0,0 +1,33 @@
+en:
+  vagrant_turbo:
+    invalid_type: "Invalid value of `%{param}`. It must be of type %{type}."
+    login_required: "Turbo.net login credentials must be specified via `username` and `password`."
+    no_path_or_inline: "One of `path` or `inline` must be set."
+    path_and_inline_set: "Only one of `path` or `inline` may be set."
+    path_invalid: "`path` for Turbo provisioner does not exist on the host system: %{path}"
+    images_folders_invalid: "`images_folder` for Turbo provisioner does not exist on the host system: %{path}"
+    invalid_encoding: |-
+      Invalid encoding '%{actual}' for script at '%{path}'.
+      Must be '%{default}' or UTF-8.
+
+    check_install: "Checking Turbo installation..."
+    already_installed: "Turbo is installed on this machine. Skipping installation..."
+    not_installed: "Turbo is not installed on this machine. Installing..."
+    install_failed: "Turbo installation failed. Something went terribly wrong. Login to the guest machine and install it manually."
+
+    no_images_to_run: "No images specified to run in the container"
+
+    no_images: "There are no images exist in the directory on the host system, skipping it: %{path}"
+    import_image: "Importing image on the guest system: %{path}..."
+
+    login: "Login as %{username}..."
+    running: "Running %{script}..."
+    invalid_parameter: "Unknown `%{param}` value. Use one of valid values: %{values}"
+    startup_file_with_path_or_inline: "Startup file cannot be set if path or inline are used"
+    check_quota: "Checking %{quota_name} quota"
+    quota_protected_by_group_policy_increase_info: "Quota is protected by Group Policy and must be changed manually. For more information visit https://msdn.microsoft.com/en-us/library/windows/desktop/ee309367(v=vs.85).aspx"
+    small_quota_warning: "Small quota may cause provisioning failure with`System.OutOfMemoryException` or `System.StackOverflowException`"
+    quota_below_recommended_limit: "%{quota_name} is below the recommended threshold of %{recommended_limit}MB (current value: %{quota_limit}MB)."
+    quota_increase_info: "To increase the quota set a new value using 'max_memory_per_shell' key in turbo provisioner or execute the following command on guest machine:\n\nwinrm set winrm/config/winrs @{%{quota_name}=\"%{recommended_limit}\"}"
+    quota_set_to: "Quota %{quota_name} set to %{quota_limit}"
+    execute_command: "Executing command: %{command}"

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+require "vagrant-turbo"

data/vagrant-turbo.gemspec

@@ -0,0 +1,24 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'vagrant-turbo/version'
+
+Gem::Specification.new do |s|
+  s.name          = 'vagrant-turbo'
+  s.version       = VagrantPlugins::Turbo::VERSION
+  s.platform      = Gem::Platform::CURRENT
+  s.authors       = 'Turbo.net'
+  s.email         = 'support@turbo.net'
+  s.summary       = 'Enables Vagrant to manage Turbo containers'
+  s.description   = 'Enables Vagrant to manage Turbo containers'
+  s.homepage      = 'https://github.com/turboapps/vagrant'
+  s.license       = 'MIT'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_paths = %w[lib]
+
+  s.add_development_dependency 'bundler', '~> 1.10'
+  s.add_development_dependency 'rake', '~> 10.0'
+  s.add_development_dependency 'rspec', '~> 3.3'
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: vagrant-turbo
+version: !ruby/object:Gem::Version
+  version: 0.0.1.pre
+platform: x86-mingw32
+authors:
+- Turbo.net
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-11-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+description: Enables Vagrant to manage Turbo containers
+email: support@turbo.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/vagrant-turbo.rb
+- lib/vagrant-turbo/cap/windows/turbo_install.rb
+- lib/vagrant-turbo/cap/windows/turbo_installed.rb
+- lib/vagrant-turbo/cap/windows/winrm_get_quota.rb
+- lib/vagrant-turbo/cap/windows/winrm_set_quota.rb
+- lib/vagrant-turbo/client.rb
+- lib/vagrant-turbo/config.rb
+- lib/vagrant-turbo/installer.rb
+- lib/vagrant-turbo/plugin.rb
+- lib/vagrant-turbo/provisioner.rb
+- lib/vagrant-turbo/version.rb
+- locales/en.yml
+- spec/spec_helper.rb
+- vagrant-turbo.gemspec
+homepage: https://github.com/turboapps/vagrant
+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: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Enables Vagrant to manage Turbo containers
+test_files: []