Unable to run vagrant on my pc

[tajoel2005]

I am always getting the same error message when running any command: C:/HashiCorp/Vagrant/embedded/mingw64/lib/ruby/2.7.0/json/common.rb:156:in `initialize’: negative string size (or size too big) (ArgumentError)

I found somewhere that it may be related to the fact that i have a special character on my AzureAD account : C:\Users\JoëlWafo
Unfortunately it is not something i can’t change as it is a work pc. Any idea how to fix it?

[Alistair_KodeKloud]

Hi @tajoel2005

The error is coming from the JSON parser within Vagrant. Further reading indicates that the file it’s trying to parse is the machine index which for you should be found in

C:\Users\JoëlWafo\.vagrant.d\data\machine-index\index

If this is stupidly large, then that will be crashing it.

Possible solution:

1. Uninstall vagrant
2. Delete the .vagrant.d directory if the uninstall did not.
3. Reinstall

Also ensure you have latest versions of that and of VirtualBox.

You can also run vagrant with --debug to see more detail of the errors.

[tajoel2005]

thanks @Alistair_KodeKloud . I have done the reinstallation and delete the .vagrant.d directory

After the installation when testing any vagrant command i am getting now a different error message. Any idea ? unable to find any information on google search so far

1: from C:/HashiCorp/Vagrant/embedded/gems/2.3.0/gems/vagrant-2.3.0/bin/vagrant:109:in <main>' C:/HashiCorp/Vagrant/embedded/gems/2.3.0/gems/vagrant-2.3.0/bin/vagrant:261:in rescue in ': failed to allocate memory (NoMemoryError)

[Alistair_KodeKloud]

It’s telling you it cannot allocate memory.

Straight after getting this error, open a PowerShell window and paste this script in to see a summary of memory usage

 # Get Computer Object
 $CompObject =  Get-WmiObject -Class WIN32_OperatingSystem
 $Memory = ((($CompObject.TotalVisibleMemorySize - $CompObject.FreePhysicalMemory)*100)/ $CompObject.TotalVisibleMemorySize)
 
 # Top 5 process Memory Usage (MB)
 $processMemoryUsage = Get-WmiObject WIN32_PROCESS | Sort-Object -Property ws -Descending |
    Select-Object -first 5 processname, @{Name="Mem Usage(MB)";Expression={[math]::round($_.ws / 1mb)}}

 Write-Host "`nMemory usage in Percentage:" $Memory "`n" ($processMemoryUsage | Out-String)
 

I am currently using Vagrant 2.2.19 which works fine for me.

[tajoel2005]

thanks @Alistair_KodeKloud look like the memory allocation error message is not related to the memory itself. I have 15GB available on my pc. I have rebooted and run vagrant command immediately after the computer start but still same error. Also i have a screenshot of the result for the command you suggested to run. As you can only 42% of the memory is used

[tajoel2005]

I forgot to mention that i was getting the memory allocation error message because i tried to install the 32bit version of Vagrant.
I just removed it and reinstall 64bit and back again the to the original error message. No change

[Alistair_KodeKloud]

From the stack trace, we can see that it is definitely complaining about the machine index file, which should be at the path I mentioned in my first reply.

Take a look for that file.

• Does it exist?
• How big is it?
• Is it valid JSON (and has no garbage characters in)?

You can also edit some debug into the ruby code. You’ll need to open a text editor “As Administrator” to do this.

In C:\HashiCorp\Vagrant\embedded\mingw64\lib\ruby\2.7.0\json\common.rb at line 337, insert this line after end

    puts "Json input length: #{source.length}"

In C:\HashiCorp\Vagrant\embedded\gems\2.2.19\gems\vagrant-2.2.19\lib\vagrant\machine_index.rb at line 320, insert this line after begin

        puts "Index file: #{@index_file.to_s}"

[tajoel2005]

• Does it exist? Yes the file exist
• How big is it? 16KB is it big ?
• Is it valid JSON (and has no garbage characters in)? the contain of the file look ok to me.

I have added the two lines you suggested.

Now im getting an error message at that specific line.
This is a brand new installation of vagrant. I don’t understand why so many issues. look like there is an issue with my machine. Don’t know what problem exactly unfortunately
See err:

’
*** 4: from C:/HashiCorp/Vagrant/embedded/mingw64/lib/ruby/2.7.0/json.rb:2:in <top (required)>'*** *** 3: from C:/HashiCorp/Vagrant/embedded/mingw64/lib/ruby/2.7.0/rubygems/core_ext/kernel_require.rb:83:in require’***
*** 2: from C:/HashiCorp/Vagrant/embedded/mingw64/lib/ruby/2.7.0/rubygems/core_ext/kernel_require.rb:83:in require'*** *** 1: from C:/HashiCorp/Vagrant/embedded/mingw64/lib/ruby/2.7.0/json/common.rb:5:in <top (required)>'***
C:/HashiCorp/Vagrant/embedded/mingw64/lib/ruby/2.7.0/json/common.rb:339:in <module:JSON>': undefined local variable or method source’ for JSON:Module (NameError)

[Alistair_KodeKloud]

Did you get your editor to format the JSON file so it’s not one continuous line just of ease of reading?

Input length line needs to go here, between end and result =:

Index file line goes here, between begin and data at the same indentation as data:

If we can’t get to the bottom of this, then you will need to raise an issue on their github site including all the information gathered so far.

[tajoel2005]

Yes i have added those lines as you recommeded. No changes so far
What these lines are supposed to to ? Provide more information to debug the issue?

the error message remains the same: cked_reload’
3: from C:/HashiCorp/Vagrant/embedded/mingw64/lib/ruby/2.7.0/json/common.rb:335:in load' 2: from C:/HashiCorp/Vagrant/embedded/mingw64/lib/ruby/2.7.0/json/common.rb:156:in parse’
1: from C:/HashiCorp/Vagrant/embedded/mingw64/lib/ruby/2.7.0/json/common.rb:156:in new' C:/HashiCorp/Vagrant/embedded/mingw64/lib/ruby/2.7.0/json/common.rb:156:in initialize’: negative string size (or size too big) (ArgumentError)

[tajoel2005]

here is the actual file content C:\HashiCorp\Vagrant\embedded\mingw64\lib\ruby\2.7.0\json\common

#frozen_string_literal: false
require ‘json/version’
require ‘json/generic_object’

module JSON
class << self
# If object is string-like, parse the string and return the parsed
# result as a Ruby data structure. Otherwise generate a JSON text from the
# Ruby data structure object and return it.
#
# The opts argument is passed through to generate/parse respectively.
# See generate and parse for their documentation.
def [](object, opts = {})
if object.respond_to? :to_str
JSON.parse(object.to_str, opts)
else
JSON.generate(object, opts)
end
end

# Returns the JSON parser class that is used by JSON. This is either
# JSON::Ext::Parser or JSON::Pure::Parser.
attr_reader :parser

# Set the JSON parser class _parser_ to be used by JSON.
def parser=(parser) # :nodoc:
  @parser = parser
  remove_const :Parser if const_defined?(:Parser, false)
  const_set :Parser, parser
end

# Return the constant located at _path_. The format of _path_ has to be
# either ::A::B::C or A::B::C. In any case, A has to be located at the top
# level (absolute namespace path?). If there doesn't exist a constant at
# the given path, an ArgumentError is raised.
def deep_const_get(path) # :nodoc:
  path.to_s.split(/::/).inject(Object) do |p, c|
    case
    when c.empty?                  then p
    when p.const_defined?(c, true) then p.const_get(c)
    else
      begin
        p.const_missing(c)
      rescue NameError => e
        raise ArgumentError, "can't get const #{path}: #{e}"
      end
    end
  end
end

# Set the module _generator_ to be used by JSON.
def generator=(generator) # :nodoc:
  old, $VERBOSE = $VERBOSE, nil
  @generator = generator
  generator_methods = generator::GeneratorMethods
  for const in generator_methods.constants
    klass = deep_const_get(const)
    modul = generator_methods.const_get(const)
    klass.class_eval do
      instance_methods(false).each do |m|
        m.to_s == 'to_json' and remove_method m
      end
      include modul
    end
  end
  self.state = generator::State
  const_set :State, self.state
  const_set :SAFE_STATE_PROTOTYPE, State.new
  const_set :FAST_STATE_PROTOTYPE, State.new(
    :indent         => '',
    :space          => '',
    :object_nl      => "",
    :array_nl       => "",
    :max_nesting    => false
  )
  const_set :PRETTY_STATE_PROTOTYPE, State.new(
    :indent         => '  ',
    :space          => ' ',
    :object_nl      => "\n",
    :array_nl       => "\n"
  )
ensure
  $VERBOSE = old
end

# Returns the JSON generator module that is used by JSON. This is
# either JSON::Ext::Generator or JSON::Pure::Generator.
attr_reader :generator

# Returns the JSON generator state class that is used by JSON. This is
# either JSON::Ext::Generator::State or JSON::Pure::Generator::State.
attr_accessor :state

# This is create identifier, which is used to decide if the _json_create_
# hook of a class should be called. It defaults to 'json_class'.
attr_accessor :create_id

end
self.create_id = ‘json_class’

NaN = 0.0/0

Infinity = 1.0/0

MinusInfinity = -Infinity

The base exception for JSON errors.

class JSONError < StandardError
def self.wrap(exception)
obj = new(“Wrapped(#{exception.class}): #{exception.message.inspect}”)
obj.set_backtrace exception.backtrace
obj
end
end

This exception is raised if a parser error occurs.

class ParserError < JSONError; end

This exception is raised if the nesting of parsed data structures is too

deep.

class NestingError < ParserError; end

:stopdoc:

class CircularDatastructure < NestingError; end

:startdoc:

This exception is raised if a generator or unparser error occurs.

class GeneratorError < JSONError; end

For backwards compatibility

UnparserError = GeneratorError

This exception is raised if the required unicode support is missing on the

system. Usually this means that the iconv library is not installed.

class MissingUnicodeSupport < JSONError; end

module_function

Parse the JSON document source into a Ruby data structure and return it.

opts can have the following

keys:

* max_nesting: The maximum depth of nesting allowed in the parsed data

structures. Disable depth checking with :max_nesting => false. It

defaults to 100.

* allow_nan: If set to true, allow NaN, Infinity and -Infinity in

defiance of RFC 7159 to be parsed by the Parser. This option defaults

to false.

* symbolize_names: If set to true, returns symbols for the names

(keys) in a JSON object. Otherwise strings are returned. Strings are

the default.

* create_additions: If set to false, the Parser doesn’t create

additions even if a matching class and create_id was found. This option

defaults to false.

* object_class: Defaults to Hash

* array_class: Defaults to Array

def parse(source, opts = {})
Parser.new(source, **(opts||{})).parse
end

Parse the JSON document source into a Ruby data structure and return it.

The bang version of the parse method defaults to the more dangerous values

for the opts hash, so be sure only to parse trusted source documents.

opts can have the following keys:

* max_nesting: The maximum depth of nesting allowed in the parsed data

structures. Enable depth checking with :max_nesting => anInteger. The

parse! methods defaults to not doing max depth checking: This can be

dangerous if someone wants to fill up your stack.

* allow_nan: If set to true, allow NaN, Infinity, and -Infinity in

defiance of RFC 7159 to be parsed by the Parser. This option defaults

to true.

* create_additions: If set to false, the Parser doesn’t create

additions even if a matching class and create_id was found. This option

defaults to false.

def parse!(source, opts = {})
opts = {
:max_nesting => false,
:allow_nan => true
}.merge(opts)
Parser.new(source, **(opts||{})).parse
end

Generate a JSON document from the Ruby data structure obj and return

it. state is * a JSON::State object,

* or a Hash like object (responding to to_hash),

* an object convertible into a hash by a to_h method,

that is used as or to configure a State object.

It defaults to a state object, that creates the shortest possible JSON text

in one line, checks for circular data structures and doesn’t allow NaN,

Infinity, and -Infinity.

A state hash can have the following keys:

* indent: a string used to indent levels (default: ‘’),

* space: a string that is put after, a : or , delimiter (default: ‘’),

* space_before: a string that is put before a : pair delimiter (default: ‘’),

* object_nl: a string that is put at the end of a JSON object (default: ‘’),

* array_nl: a string that is put at the end of a JSON array (default: ‘’),

* allow_nan: true if NaN, Infinity, and -Infinity should be

generated, otherwise an exception is thrown if these values are

encountered. This options defaults to false.

* max_nesting: The maximum depth of nesting allowed in the data

structures from which JSON is to be generated. Disable depth checking

with :max_nesting => false, it defaults to 100.

See also the fast_generate for the fastest creation method with the least

amount of sanity checks, and the pretty_generate method for some

defaults for pretty output.

def generate(obj, opts = nil)
if State === opts
state, opts = opts, nil
else
state = SAFE_STATE_PROTOTYPE.dup
end
if opts
if opts.respond_to? :to_hash
opts = opts.to_hash
elsif opts.respond_to? :to_h
opts = opts.to_h
else
raise TypeError, “can’t convert #{opts.class} into Hash”
end
state = state.configure(opts)
end
state.generate(obj)
end

:stopdoc:

I want to deprecate these later, so I’ll first be silent about them, and

later delete them.

alias unparse generate
module_function :unparse

:startdoc:

Generate a JSON document from the Ruby data structure obj and return it.

This method disables the checks for circles in Ruby objects.

WARNING: Be careful not to pass any Ruby data structures with circles as

obj argument because this will cause JSON to go into an infinite loop.

def fast_generate(obj, opts = nil)
if State === opts
state, opts = opts, nil
else
state = FAST_STATE_PROTOTYPE.dup
end
if opts
if opts.respond_to? :to_hash
opts = opts.to_hash
elsif opts.respond_to? :to_h
opts = opts.to_h
else
raise TypeError, “can’t convert #{opts.class} into Hash”
end
state.configure(opts)
end
state.generate(obj)
end

:stopdoc:

I want to deprecate these later, so I’ll first be silent about them, and later delete them.

alias fast_unparse fast_generate
module_function :fast_unparse

:startdoc:

Generate a JSON document from the Ruby data structure obj and return it.

The returned document is a prettier form of the document returned by

#unparse.

The opts argument can be used to configure the generator. See the

generate method for a more detailed explanation.

def pretty_generate(obj, opts = nil)
if State === opts
state, opts = opts, nil
else
state = PRETTY_STATE_PROTOTYPE.dup
end
if opts
if opts.respond_to? :to_hash
opts = opts.to_hash
elsif opts.respond_to? :to_h
opts = opts.to_h
else
raise TypeError, “can’t convert #{opts.class} into Hash”
end
state.configure(opts)
end
state.generate(obj)
end

:stopdoc:

I want to deprecate these later, so I’ll first be silent about them, and later delete them.

alias pretty_unparse pretty_generate
module_function :pretty_unparse

:startdoc:

class << self
# The global default options for the JSON.load method:
# :max_nesting: false
# :allow_nan: true
# :allow_blank: true
attr_accessor :load_default_options
end
self.load_default_options = {
:max_nesting => false,
:allow_nan => true,
:allow_blank => true,
:create_additions => true,
}

Load a ruby data structure from a JSON source and return it. A source can

either be a string-like object, an IO-like object, or an object responding

to the read method. If proc was given, it will be called with any nested

Ruby object as an argument recursively in depth first order. To modify the

default options pass in the optional options argument as well.

BEWARE: This method is meant to serialise data from trusted user input,

like from your own database server or clients under your control, it could

be dangerous to allow untrusted users to pass JSON sources into it. The

default options for the parser can be changed via the load_default_options

method.

This method is part of the implementation of the load/dump interface of

Marshal and YAML.

def load(source, proc = nil, options = {})
opts = load_default_options.merge options
if source.respond_to? :to_str
source = source.to_str
elsif source.respond_to? :to_io
source = source.to_io.read
elsif source.respond_to?(:read)
source = source.read
end
if opts[:allow_blank] && (source.nil? || source.empty?)
source = ‘null’
end
result = parse(source, opts)
recurse_proc(result, &proc) if proc
result
end
puts “Json input length: #{source.length}”

Recursively calls passed Proc if the parsed data structure is an Array or Hash

def recurse_proc(result, &proc)
case result
when Array
result.each { |x| recurse_proc x, &proc }
proc.call result
when Hash
result.each { |x, y| recurse_proc x, &proc; recurse_proc y, &proc }
proc.call result
else
proc.call result
end
end

alias restore load
module_function :restore

class << self
# The global default options for the JSON.dump method:
# :max_nesting: false
# :allow_nan: true
# :allow_blank: true
attr_accessor :dump_default_options
end
self.dump_default_options = {
:max_nesting => false,
:allow_nan => true,
}

Dumps obj as a JSON string, i.e. calls generate on the object and returns

the result.

If anIO (an IO-like object or an object that responds to the write method)

was given, the resulting JSON is written to it.

If the number of nested arrays or objects exceeds limit, an ArgumentError

exception is raised. This argument is similar (but not exactly the

same!) to the limit argument in Marshal.dump.

The default options for the generator can be changed via the

dump_default_options method.

This method is part of the implementation of the load/dump interface of

Marshal and YAML.

def dump(obj, anIO = nil, limit = nil)
if anIO and limit.nil?
anIO = anIO.to_io if anIO.respond_to?(:to_io)
unless anIO.respond_to?(:write)
limit = anIO
anIO = nil
end
end
opts = JSON.dump_default_options
opts = opts.merge(:max_nesting => limit) if limit
result = generate(obj, opts)
if anIO
anIO.write result
anIO
else
result
end
rescue JSON::NestingError
raise ArgumentError, “exceed depth limit”
end

Encodes string using Ruby’s String.encode

def self.iconv(to, from, string)
string.encode(to, from)
end
end

module ::Kernel
private

Outputs objs to STDOUT as JSON strings in the shortest form, that is in

one line.

def j(*objs)
objs.each do |obj|
puts JSON::generate(obj, :allow_nan => true, :max_nesting => false)
end
nil
end

Outputs objs to STDOUT as JSON strings in a pretty format, with

indentation and over many lines.

def jj(*objs)
objs.each do |obj|
puts JSON::pretty_generate(obj, :allow_nan => true, :max_nesting => false)
end
nil
end

If object is string-like, parse the string and return the parsed result as

a Ruby data structure. Otherwise, generate a JSON text from the Ruby data

structure object and return it.

The opts argument is passed through to generate/parse respectively. See

generate and parse for their documentation.

def JSON(object, *args)
if object.respond_to? :to_str
JSON.parse(object.to_str, args.first)
else
JSON.generate(object, args.first)
end
end
end

Extends any Class to include json_creatable? method.

class ::Class

Returns true if this class can be used to create an instance

from a serialised JSON string. The class has to implement a class

method json_create that expects a hash as first parameter. The hash

should include the required data.

def json_creatable?
respond_to?(:json_create)
end
end

[Alistair_KodeKloud]

The line

puts "Json input length: #{source.length}"

is to tell us how long the JSON string being given to the parser is, to try to explain the error negative string size (or size too big)

The other line was to assert that the JSON being parsed is coming from the machine-index file.

negative string size (or size too big) would generally mean that either string is indeed too big which would probably mean gigabyte type sizes, or negative string size may mean corrupt data in the string, which is why we are looking to confirm that the machine-index file contains only regular characters.

Like you inferred earlier, the presence of unicode characters in the directory path (as in your name), could cause corruption elsewhere if incorrectly handled.

Apparently it is possible to have the .vagrant.d directory stored elsewhere. Try

1. Uninstall vagrant again. Close any command prompts and powershell prompts
2. Create a permanent environment variable (control panel → system → advanced system settings → advanced → environment variables) under user variables, with name VAGRANT_HOME and value being path to a directory you have write access to, and is not beneath your user profile directory, so it has no unicode charaters.
3. Reinstall it.
4. Open command prompt and execute set
   Verify that VAGRANT_HOME is present in the list (for powershell prompt, dir env:)
5. Try vagrant again. It should create either .vagrant.d within the path you set in the environment variable, or just use the folder directly.

[tajoel2005]

I have already created a permanent environment variable and it is not beneath my user profile as you can see in the screenhot

I will try to reinstall vagrant and make sure no file under the directory where my user profile is. Because i still see loader file under my profile. maybe it is a part of the issue

[tajoel2005]

i have uninstall and reinstall vagrant but no difference, same error message. as said above i have create the environment variable vagrant_home
any other idea?
here is the error message:

Installed Version: 2.2.19
Latest Version: 2.3.0

To upgrade to the latest version, visit the downloads page and
download and install the latest version of Vagrant from the URL
below:

Install | Vagrant | HashiCorp Developer

If you’re curious what changed in the latest release, view the
CHANGELOG below:

https://github.com/hashicorp/vagrant/blob/v2.3.0/CHANGELOG.md
Traceback (most recent call last):
16: from C:/HashiCorp/Vagrant/embedded/gems/2.2.19/gems/vagrant-2.2.19/bin/vagrant:234:in <main>' 15: from C:/HashiCorp/Vagrant/embedded/gems/2.2.19/gems/vagrant-2.2.19/lib/vagrant/environment.rb:775:in unload’
14: from C:/HashiCorp/Vagrant/embedded/gems/2.2.19/gems/vagrant-2.2.19/lib/vagrant/environment.rb:526:in hook' 13: from C:/HashiCorp/Vagrant/embedded/gems/2.2.19/gems/vagrant-2.2.19/lib/vagrant/action/runner.rb:34:in run’
12: from C:/HashiCorp/Vagrant/embedded/gems/2.2.19/gems/vagrant-2.2.19/lib/vagrant/environment.rb:206:in block in action_runner' 11: from C:/HashiCorp/Vagrant/embedded/gems/2.2.19/gems/vagrant-2.2.19/lib/vagrant/environment.rb:724:in machine_index’
10: from C:/HashiCorp/Vagrant/embedded/gems/2.2.19/gems/vagrant-2.2.19/lib/vagrant/environment.rb:724:in new' 9: from C:/HashiCorp/Vagrant/embedded/gems/2.2.19/gems/vagrant-2.2.19/lib/vagrant/machine_index.rb:52:in initialize’
8: from C:/HashiCorp/Vagrant/embedded/gems/2.2.19/gems/vagrant-2.2.19/lib/vagrant/machine_index.rb:348:in with_index_lock' 7: from C:/HashiCorp/Vagrant/embedded/gems/2.2.19/gems/vagrant-2.2.19/lib/vagrant/machine_index.rb:348:in open’
6: from C:/HashiCorp/Vagrant/embedded/gems/2.2.19/gems/vagrant-2.2.19/lib/vagrant/machine_index.rb:350:in block in with_index_lock' 5: from C:/HashiCorp/Vagrant/embedded/gems/2.2.19/gems/vagrant-2.2.19/lib/vagrant/machine_index.rb:53:in block in initialize’
4: from C:/HashiCorp/Vagrant/embedded/gems/2.2.19/gems/vagrant-2.2.19/lib/vagrant/machine_index.rb:320:in unlocked_reload' 3: from C:/HashiCorp/Vagrant/embedded/mingw64/lib/ruby/2.7.0/json/common.rb:335:in load’
2: from C:/HashiCorp/Vagrant/embedded/mingw64/lib/ruby/2.7.0/json/common.rb:156:in parse' 1: from C:/HashiCorp/Vagrant/embedded/mingw64/lib/ruby/2.7.0/json/common.rb:156:in new’
C:/HashiCorp/Vagrant/embedded/mingw64/lib/ruby/2.7.0/json/common.rb:156:in `initialize’: negative string size (or size too big) (ArgumentError)

C:\HashiCorp\Vagrant>

[Alistair_KodeKloud]

That leaves the final option of raising an issue on their github site at the URL I posted in an earlier message.

You’ll need to include in the issue report:

• Version of Vagrant installed
• Full version of Windows (run the following in PowerShell prompt)

  systeminfo /fo csv | ConvertFrom-Csv | select OS*
  

• The fact that your userprofile directory path contains unicode characters.
• The current location and size of the machine-index file
• The error stack trace

Have you also tried installing the same version on a different PC, or logged in as a different user on that PC that doesn’t have unicode characters in the userprofile?

[tajoel2005]

thanks @Alistair_KodeKloud

I have found somewhere on internet that it maybe related to the version of vagrant and virtualbox installed
I have already downgraded the version of vagrant to 2.0.0 but now i am getting a different error message saying that i should also use older version of virtualbox. I will test it later and if it worked i will keep those version for now

thanks again for the assistance

---

C:\Users\JoëlWafoTalom>vagrant up --provider=virtualbox
The provider ‘virtualbox’ that was requested to back the machine
‘default’ is reporting that it isn’t usable on this system. The
reason is shown below:

Vagrant has detected that you have a version of VirtualBox installed
that is not supported by this version of Vagrant. Please install one of
the supported versions listed below to use Vagrant:

4.0, 4.1, 4.2, 4.3, 5.0, 5.1

A Vagrant update may also be available that adds support for the version
you specified. Please check Install | Vagrant | HashiCorp Developer to download
the latest version.

[Alistair_KodeKloud]

For reference, I’m using Vagrant 2.2.19 with VirtualBox 6.1.36 on Windows 10

[tajoel2005]

back to square 1. I am not able to install virtualbox version 5.1 on windows 10 - not compatible says.

at this point i have no more idea. I have submitted the case you said above but i believe it will be very long and who knows if they will ever respond to it

[Christophe-Cariou]

Hi Joël,

looking for the same trouble as you, we found the reason of the bug for us and I think it’s the same for you :

• We had the same error trace ; common.rb:156:in `initialize’: negative string size (or size too big) (ArgumentError)
• We had a HUGE index file (more than 1 Gb)

At the end , the cause was an accentued character in the path to the folder containing our Vagrantfile…
After renaming the involved folder (and removing index file) everything work again !
And as you have an accent in your name, used use in your path, I suspect that it’s the same cause as us.

Cheers !