origen 0.38.0 → 0.40.0

data/lib/origen/boot.rb

@@ -0,0 +1,287 @@
+$VERBOSE = nil  # Don't care about world writable dir warnings and the like
+
+require 'pathname'
+require 'fileutils'
+
+class OrigenBootError < StandardError
+end
+
+# Keep a note of the pwd at the time when Origen was first loaded, this is initially used
+# by the site_config lookup.
+$_origen_invocation_pwd ||= Pathname.pwd
+
+load File.expand_path('../operating_systems.rb', __FILE__)
+load File.expand_path('../site_config.rb', __FILE__)
+
+# This will be referenced later in ruby_version_check, the origen used to launch
+# the process is different than the one that actually runs under bundler
+$origen_launch_root = Pathname.new(File.dirname(__FILE__)).parent
+
+# Override any influence from $LANG in the users environment
+Encoding.default_external = Encoding::UTF_8
+Encoding.default_internal = Encoding::UTF_8
+ENV['LC_ALL'] = nil
+ENV['LANG'] = nil
+ENV['LANG'] = 'en_US.UTF-8'
+
+# Are we inside an Origen application workspace?
+if defined?(ORIGEN_ROOT)
+  origen_root = ORIGEN_ROOT
+else
+  app_config = File.join('config', 'application.rb')
+  if File.exist?(app_config)
+    origen_root = Dir.pwd
+  else
+    path = Pathname.new(Dir.pwd)
+    until path.root? || origen_root
+      if File.exist?(File.join(path, app_config))
+        origen_root = path.to_s
+      else
+        path = path.parent
+      end
+    end
+  end
+end
+
+warnings = nil
+
+########################################################################################################################
+########################################################################################################################
+## If running inside an application workspace
+########################################################################################################################
+########################################################################################################################
+if origen_root
+  require_relative 'boot/app'
+
+  if ARGV.first == 'setup'
+    Origen::Boot.setup(origen_root)
+    puts
+    puts 'Your application has been setup successfully'
+    exit 0
+  else
+    warnings = Origen::Boot.app!(origen_root)
+    boot_app = true
+  end
+
+########################################################################################################################
+########################################################################################################################
+## If running outside an application and a user or central tool Origen bundle is to be used
+##
+## Note that there is a lot of duplication of the above code, however this is a copy of the original code
+## to boot up outside an app when a tool Origen bundle is present. It has been maintained separately to
+## ensure that the changes to how an application boots up do not affect the global tool installation functionality.
+########################################################################################################################
+########################################################################################################################
+elsif Origen.site_config.gem_manage_bundler && (Origen.site_config.user_install_enable || Origen.site_config.tool_repo_install_dir)
+  # Force everyone to have a consistent way of installing gems with bundler.
+  # In this case, we aren't running from an Origen application, so build everything at Origen.home instead
+  # Have two options here: if user_install_enable is true, use user_install_dir. Otherwise, use the tool_repo_install_dir
+  install_dir = Origen.site_config.user_install_enable ? File.expand_path(Origen.site_config.user_install_dir) : File.expand_path(Origen.site_config.tool_repo_install_dir)
+  unless Dir.exist?(install_dir)
+    load File.expand_path('../../lib/origen/utility/input_capture.rb', __FILE__)
+    include Origen::Utility::InputCapture
+
+    puts "Root directory '#{install_dir}' does not exist. Would you like to create it?"
+    if get_text(confirm: :return_boolean)
+      FileUtils.mkdir(install_dir)
+    else
+      puts 'Exiting with creating Origen install'
+      exit!
+    end
+  end
+
+  gemfile = File.join(install_dir, 'Gemfile')
+  unless File.exist?(gemfile)
+    # Create a default Gemfile that can be further customized by the user.
+    # Initial Gemfile only requires Origen. Nothing else. Essentially a blank installation.
+    Dir.chdir(install_dir) do
+      `bundle init`
+    end
+    # The above will give a general Gemfile from Bundler. We'll just append "gem 'origen' to the end.
+    File.open(gemfile, 'a') do |f|
+      f << "gem 'origen'\n"
+    end
+  end
+  ENV['BUNDLE_GEMFILE'] = gemfile
+  ENV['BUNDLE_PATH'] = File.expand_path(Origen.site_config.gem_install_dir)
+  ENV['BUNDLE_BIN'] = File.join(install_dir, 'lbin')
+
+  origen_exec = File.join(ENV['BUNDLE_BIN'], 'origen')
+
+  # If the user/tool bundle already exists but we have not been invoked through that, abort this thread
+  # and re-launch under the required bundler environment
+  if File.exist?(origen_exec) && !ENV['BUNDLE_BIN_PATH'] && File.exist?(ENV['BUNDLE_PATH'])
+    exec Gem.ruby, origen_exec, *ARGV
+    exit 0
+  else
+    boot_app = false
+  end
+
+  if File.exist?(ENV['BUNDLE_GEMFILE'])
+    # Overriding bundler here so that bundle install can be automated as required
+    require 'bundler/shared_helpers'
+    if Bundler::SharedHelpers.in_bundle?
+      require 'bundler'
+      if STDOUT.tty?
+        begin
+          fail OrigenBootError unless File.exist?(ENV['BUNDLE_BIN'])
+          Bundler.setup
+          fail OrigenBootError unless File.exist?(ENV['BUNDLE_BIN'])
+        rescue Gem::LoadError, Bundler::BundlerError, OrigenBootError => e
+          cmd = "bundle install --gemfile #{ENV['BUNDLE_GEMFILE']} --binstubs #{ENV['BUNDLE_BIN']} --path #{ENV['BUNDLE_PATH']}"
+          # puts cmd
+          puts 'Installing required gems...'
+          puts
+          `chmod o-w #{install_dir}` # Stops some annoying world writable warnings during install
+          `chmod o-w #{install_dir}/bin` if File.exist?("#{install_dir}/bin")
+          `chmod o-w #{install_dir}/.bin` if File.exist?("#{install_dir}/.bin")
+          result = false
+
+          Bundler.with_clean_env do
+            if Origen.os.unix?
+              if Origen.site_config.gem_build_switches
+                Origen.site_config.gem_build_switches.each do |switches|
+                  `bundle config build.#{switches}`
+                end
+              end
+            end
+            result = system(cmd)
+          end
+          `chmod o-w #{ENV['BUNDLE_BIN']}`
+          # Make .bat versions of all executables, Bundler should really be doing this when running
+          # on windows
+          if Origen.os.windows?
+            bat_present = File.exist? "#{install_dir}/lbin/origen.bat"
+            Dir.glob("#{install_dir}/lbin/*").each do |bin|
+              unless bin =~ /.bat$/
+                bat = "#{bin}.bat"
+                unless File.exist?(bat)
+                  File.open(bat, 'w') { |f| f.write('@"ruby.exe" "%~dpn0" %*') }
+                end
+              end
+            end
+            if !bat_present && !result
+              puts 'Some Windows specific updates to your workspace were required, please re-run the last command'
+              exit 0
+            end
+          end
+          if result
+            exec "origen #{ARGV.join(' ')}"
+            exit 0
+          else
+            puts
+            puts "If you have just updated a gem version and are now getting an error that Bundler cannot find compatible versions for it then first try running 'bundle update <gemname>'."
+            puts "For example if you have just changed the version of origen_core run 'bundle update origen_core'."
+            exit 1
+          end
+        end
+      else
+        Bundler.setup
+      end
+    end
+    require 'bundler/setup'
+    require 'origen'
+  else
+    $LOAD_PATH.unshift "#{File.expand_path(File.dirname(__FILE__))}/../lib"
+    require 'origen'
+  end
+
+########################################################################################################################
+########################################################################################################################
+## We are running outside of an app and no-special global Origen tool setup is present
+########################################################################################################################
+########################################################################################################################
+else
+  $LOAD_PATH.unshift "#{File.expand_path(File.dirname(__FILE__))}/../lib"
+  require 'origen'
+end
+
+########################################################################################################################
+########################################################################################################################
+
+begin
+  # Now that the runtime Origen version is loaded, we need to re-load the site config.
+  # This is because the version of the site_config that was originally loaded above has instantiated
+  # a site_config object, whereas earlier versions of Origen (which could now be loaded), instantiated
+  # a simple hash instead.
+  # Reloading now will ensure consistency between the site config object and the version of
+  # Origen that is now live.
+  Origen.instance_variable_set(:@site_config, nil)
+  load 'origen/site_config.rb'
+  require 'colored'
+  # Emit all broadcast messages before executing all commands
+  if Origen.site_config.broadcast_info
+    puts
+    Array(Origen.site_config.broadcast_info).each { |line| puts line }
+    puts
+  end
+  if Origen.site_config.broadcast_warning
+    puts
+    Array(Origen.site_config.broadcast_warning).each { |line| puts line.yellow }
+    puts
+  end
+  if Origen.site_config.broadcast_danger
+    puts
+    Array(Origen.site_config.broadcast_danger).each { |line| puts line.red }
+    puts
+  end
+  if Origen.site_config.broadcast_success
+    puts
+    Array(Origen.site_config.broadcast_success).each { |line| puts line.green }
+    puts
+  end
+
+  # If this script has been invoked from within an Origen application then open
+  # up all commands, if not then only allow the command to create a new Origen
+  # application.
+  if origen_root && boot_app
+    puts warnings if warnings && Origen.version >= '0.40.0'
+    require 'origen/commands'
+  else
+    require 'origen/commands_global'
+  end
+rescue Exception => e
+  # A formatted stack dump will not be printed if the application ends via 'exit 0' or 'exit 1'. In that
+  # case the application code is responsible for printing a helpful error message.
+  # This will intercept all other exits, e.g. via 'fail "Something has done wrong"', and split the stack
+  # dump to separate all in-application references from Origen core/plugin references.
+  if e.is_a?(SystemExit)
+    exit e.status
+  else
+    puts
+    if Origen.app_loaded?
+      puts 'COMPLETE CALL STACK'
+      puts '-------------------'
+      puts e.message unless e.is_a?(SystemExit)
+      puts e.backtrace
+
+      puts
+      puts 'APPLICATION CALL STACK'
+      puts '----------------------'
+      puts e.message unless e.is_a?(SystemExit)
+      # Only print out the application stack trace by default, if verbose logging is
+      # enabled then output the full thing
+      e.backtrace.each do |line|
+        path = Pathname.new(line)
+        if path.absolute?
+          if line =~ /^#{Origen.root}/ && line !~ /^#{Origen.root}\/lbin/
+            puts line
+          end
+        else
+          puts line unless line =~ /^.\/lbin/
+        end
+      end
+    else
+      puts 'COMPLETE CALL STACK'
+      puts '-------------------'
+      puts e.message unless e.is_a?(SystemExit)
+      puts e.backtrace
+    end
+    exit 1
+  end
+ensure
+  if Origen.app_loaded?
+    Origen.app.listeners_for(:on_origen_shutdown).each(&:on_origen_shutdown)
+    Origen.app.runner.shutdown
+  end
+end

data/lib/origen/commands/archive.rb

@@ -0,0 +1,175 @@
+require 'optparse'
+require 'fileutils'
+require 'find'
+require 'bundler'
+
+options = {}
+options[:exclude] = []
+
+opt_parser = OptionParser.new do |opts|
+  opts.banner = 'Usage: origen archive [options]'
+  opts.on('--local', 'Install gems within your app so that it can run completely standalone, no archive is created') { options[:local] = true }
+  opts.on('--no-local', "Reverses a previously executed 'origen archive --local' operation, returning the app to use a conventional gem installation") { options[:no_local] = true }
+  opts.on('-e', '--exclude DIR', 'Exclude the given directory from the archive, e.g. --exclude simulation') { |dir| options[:exclude] << dir }
+end
+opt_parser.parse! ARGV
+
+origen_binstub = File.join(Origen.root, 'lbin', 'origen')
+
+unless  File.exist?(origen_binstub) && File.read(origen_binstub) =~ /This file was generated by Origen/
+  puts 'An archive can only be created after your application is running the latest Origen boot system,'
+  puts 'run the following command to update your application and then try again:'
+  puts
+  puts '  origen setup'
+  puts
+  exit 1
+end
+
+if options[:no_local]
+  Dir.chdir Origen.root do
+    dir = File.join('vendor', 'gems')
+    FileUtils.rm_rf(dir) if File.exist?(dir)
+  end
+  passed = true
+  Bundler.with_clean_env do
+    passed = system('origen -v')
+  end
+  if passed
+    Origen.log.success 'Local gems have been removed and your application has been restored to use a conventional gem installation.'
+    exit 0
+  else
+    Origen.log.error 'A problem was encountered when trying to boot your application after removing local gems!'
+    exit 1
+  end
+end
+
+Origen.log.info 'Preparing the workspace' unless options[:local]
+tmp1 = File.join(Origen.root, '..', "#{Origen.app.name}_copy")
+name = "#{Origen.app.name}-#{Origen.app.version}"
+tmpdir = File.join(Origen.root, 'tmp')
+tmp = File.join(tmpdir, name)
+archive = File.join(Origen.root, 'tmp', "#{name}.origen")
+unless options[:local]
+  FileUtils.rm_rf(tmp1) if File.exist?(tmp1)
+  FileUtils.rm_rf(tmp) if File.exist?(tmp)
+  FileUtils.rm_rf(archive) if File.exist?(archive)
+end
+
+exclude_dirs = ['.bundle', 'output', 'tmp', 'web', 'waves', '.git', '.ref', 'dist', 'log', '.lsf', '.session'] + options[:exclude]
+
+unless options[:local]
+  begin
+    Origen.log.info 'Creating a copy of the application'
+    if Origen.os.linux?
+      Dir.chdir Origen.root do
+        cmd = "rsync -av --progress . tmp/#{name} --exclude tmp"
+        exclude_dirs.each do |dir|
+          cmd += " --exclude #{dir}"
+        end
+        passed = system cmd
+        unless passed
+          Origen.log.error 'A problem was encountered when creating a copy of your application, archive aborted!'
+          exit 1
+        end
+      end
+    else
+      FileUtils.mkdir_p(tmp1)
+      FileUtils.cp_r "#{Origen.root}/.", tmp1
+      FileUtils.mv tmp1, tmp
+    end
+    # Remove all .svn or .SYNC directories
+    Find.find(tmp) do |path|
+      n = File.basename(path)
+      if FileTest.directory?(path) && (n == '.svn' || n == '.SYNC')
+        puts "Removing: #{path}"
+        FileUtils.remove_dir(path)
+      end
+    end
+  ensure
+    FileUtils.rm_rf(tmp1) if File.exist?(tmp1)
+  end
+end
+
+Origen.log.info 'Fetching all required gems' unless options[:local]
+dir = options[:local] ? Origen.root : tmp
+Dir.chdir dir do
+  # When archiving, also include copies of all gem packages for other platforms, this will help if the
+  # archive needs to run on a different platform to the one used to create it in the future
+  unless options[:local]
+    Bundler.with_clean_env do
+      FileUtils.rm_rf('.bundle') if File.exist?('.bundle')
+      system 'hash -r'  # Ignore fail if not on bash
+
+      passed = system "GEM_HOME=#{File.expand_path(Origen.site_config.gem_install_dir)} bundle package --all --all-platforms --no-install"
+      unless passed
+        Origen.log.error 'A problem was encountered when packaging the gems, archive aborted!'
+        exit 1
+      end
+      FileUtils.rm_rf('.bundle') if File.exist?('.bundle')
+    end
+  end
+
+  Origen.log.info 'Installing gems into the application (this could take a while)'
+  FileUtils.mkdir_p(File.join('vendor', 'gems'))
+  require 'origen/boot/app'
+  begin
+    Origen::Boot.setup(dir)
+    Origen::Boot.setup_bundler(dir)
+  rescue Exception => e
+    Origen.log.error e.to_s
+    Origen.log.error 'A problem was encountered setting up the workspace, archive aborted!'
+    exit 1
+  end
+  FileUtils.touch('.origen_archive') unless options[:local]
+
+  Bundler.with_clean_env do
+    passed = system('bundle') && system('origen -v')
+    unless passed
+      Origen.log.error 'A problem was encountered installing the gem bundle, archive aborted!'
+      exit 1
+    end
+  end
+
+  unless options[:local]
+    Origen.log.info 'Removing all temporary and output files'
+    exclude_dirs.each do |dir|
+      if File.exist?(dir)
+        if File.symlink?(dir)
+          FileUtils.rm(dir)
+        else
+          FileUtils.rm_rf(dir)
+        end
+      end
+    end
+  end
+end
+
+if options[:local]
+  Origen.log.success 'Gems have been successfully installed to your application'
+  Origen.log.success ''
+  Origen.log.success 'If you ran this in error or otherwise want to undo it, run the following command:'
+  Origen.log.success '  origen archive --no-local'
+  Origen.log.success ''
+else
+  Origen.log.info 'Creating archive'
+  Dir.chdir tmpdir do
+    FileUtils.rm_rf('.bundle') if File.exist?('.bundle')
+    passed = system "tar -cvzf #{name}.origen ./#{name}"
+    unless passed
+      Origen.log.error 'A problem was encountered creating the tarball, archive aborted!'
+      exit 1
+    end
+
+    Origen.log.info 'Cleaning up'
+    FileUtils.rm_rf(name)
+  end
+
+  puts
+  begin
+    size = `du -sh tmp/#{name}.origen`.split(/\s+/).first
+    Origen.log.success "Your application archive is complete and is #{size}B in size"
+  rescue
+    Origen.log.success 'Your application archive is complete'
+  end
+  Origen.log.success archive
+end

data/lib/origen/commands/extract.rb

@@ -0,0 +1,43 @@
+require 'optparse'
+require 'fileutils'
+require 'bundler'
+
+options = {}
+
+opt_parser = OptionParser.new do |opts|
+  opts.banner = 'Usage: origen extract FILE [options]'
+end
+opt_parser.parse! ARGV
+
+archive = ARGV.first
+
+unless File.exist?(archive)
+  Origen.log.error "File not found: #{archive}"
+  exit 1
+end
+
+dirname = Pathname.new(archive).basename('.origen').to_s
+
+if File.exist?(dirname)
+  Origen.log.error "The application directory already exists (#{dirname}), delete it and then try again if you want to overwrite it"
+  exit 1
+end
+
+passed = system "tar -xvzf #{archive}"
+unless passed
+  Origen.log.error 'A problem was encountered extracting the tarball, extraction aborted!'
+  exit 1
+end
+
+Dir.chdir dirname do
+  Bundler.with_clean_env do
+    Origen.log.info 'Trying to boot the application...'
+
+    passed = system "#{File.join('lbin', 'origen')} -v"
+    if passed
+      Origen.log.success 'Your application has been extracted and can boot up'
+    else
+      Origen.log.error 'Something went wrong at the final hurdle, your application has been extracted but cannot boot'
+    end
+  end
+end

data/lib/origen/commands/new.rb

@@ -62,7 +62,12 @@ else
   end
 end
 
-generators = [['http://rubygems.org', 'origen_app_generators']] + Array(Origen.site_config.app_generators)
+generators = [['https://rubygems.org', 'origen_app_generators']] + Array(Origen.site_config.app_generators)
+
+def use_packaged_generators
+  FileUtils.cp_r Origen.top.join('origen_app_generators').to_s, '.'
+  FileUtils.mv 'origen_app_generators', '0'
+end
 
 if update_required
   puts 'Fetching the latest app generators...'
@@ -73,41 +78,46 @@ if update_required
     generators.each_with_index do |gen, i|
       # If a reference to a gem from a gem server
       if gen.is_a?(Array)
-        response = HTTParty.get("#{gen[0]}/api/v1/dependencies.json?gems=#{gen[1]}")
+        begin
+          response = HTTParty.get("#{gen[0]}/api/v1/dependencies.json?gems=#{gen[1]}", timeout: 2)
 
-        if response.success?
-          latest_version = JSON.parse(response.body).map { |v| v['number'] }.max
-
-          response = HTTParty.get("#{gen[0]}/gems/#{gen[1]}-#{latest_version}.gem")
           if response.success?
-            File.open("#{gen[1]}-#{latest_version}.gem", 'wb') do |f|
-              f.write response.parsed_response
+            latest_version = JSON.parse(response.body).map { |v| v['number'] }.max
+
+            response = HTTParty.get("#{gen[0]}/gems/#{gen[1]}-#{latest_version}.gem", timeout: 5)
+            if response.success?
+              File.open("#{gen[1]}-#{latest_version}.gem", 'wb') do |f|
+                f.write response.parsed_response
+              end
+
+              `gem unpack #{gen[1]}-#{latest_version}.gem`
+              FileUtils.rm_rf("#{gen[1]}-#{latest_version}.gem")
+              FileUtils.mv("#{gen[1]}-#{latest_version}", i.to_s)
+            else
+              use_packaged_generators if i == 0
             end
           else
-            puts "Sorry, could not find generator #{gen[1]} version #{latest_version}"
+            use_packaged_generators if i == 0
           end
-
-          `gem unpack #{gen[1]}-#{latest_version}.gem`
-          FileUtils.rm_rf("#{gen[1]}-#{latest_version}.gem")
-          FileUtils.mv("#{gen[1]}-#{latest_version}", i.to_s)
-
-        else
-          puts "Failed to get generator #{gen[1]}, the response from the server was:"
-          puts response.body
+        rescue
+          use_packaged_generators if i == 0
         end
 
       # If a reference to a git repo
       elsif gen.to_s =~ /\.git$/
-        Origen::RevisionControl.new(remote: gen, local: i.to_s).checkout(version: 'master', force: true)
+        begin
+          Origen::RevisionControl.new(remote: gen, local: i.to_s).checkout(version: 'master', force: true)
+        rescue
+          # Better for the user not to crash here, not much we can do otherwise
+        end
 
       # Assume a reference to a folder
       else
-        if File.exist?(gen)
-          FileUtils.cp_r(gen, i.to_s)
-        else
-          puts "Failed to find generator at #{gen}"
+        begin
+          FileUtils.cp_r(gen, i.to_s) if File.exist?(gen)
+        rescue
+          # Better for the user not to crash here, not much we can do otherwise
         end
-
       end
     end
 

data/lib/origen/commands.rb

@@ -230,7 +230,8 @@ end.compact
 
 case @command
 when 'generate', 'program', 'compile', 'merge', 'interactive', 'target', 'environment',
-     'save', 'lsf', 'web', 'time', 'dispatch', 'rc', 'lint', 'plugin', 'fetch', 'mode', 'gem' # , 'add'
+     'save', 'lsf', 'web', 'time', 'dispatch', 'rc', 'lint', 'plugin', 'fetch', 'mode', 'gem',
+     'archive'
 
   require "origen/commands/#{@command}"
   exit 0 unless @command == 'interactive'
@@ -271,12 +272,14 @@ The core origen commands are:
  compile      Compile a template file or directory (short-cut alias: "c")
  exec         Execute any Ruby file with access to your app environment
 
+ setup        Setup an app workspace for the first time, or fix if it can't boot
  rc           Revision control commands, see -h for details
  save         Save the new or changed files from the last run or a given log file
  lsf          Monitor and manage LSF jobs (short-cut alias: "l")
  web          Web page tools, see -h for details
  time         Tools for test time analysis and forecasting
  lint         Lint and style check (and correct) your application code
+ archive      Create an archive of your current application state
  site         Monitor and manage the Origen site configuration
   EOT
   cmds.split(/\n/).each do |line|

data/lib/origen/commands_global.rb

@@ -88,8 +88,8 @@ end
 
 case @command
 
-when 'new'
-  require 'origen/commands/new'
+when 'new', 'extract'
+  require "origen/commands/#{@command}"
   exit 0
 
 when '--version', '-v'
@@ -119,6 +119,7 @@ The following commands are available:
               new origen application workspace in "./my_app"
  interactive  Start an interactive Origen console (short-cut alias: "i"), this is just
               IRB with the 'origen' lib loaded automatically
+ extract      Extract an Origen application archive (.origen file created with the archive command)
  site         Monitor and manage the Origen site configuration
   EOT
   cmds.split(/\n/).each do |line|

data/lib/origen/operating_systems.rb

@@ -22,6 +22,10 @@ module Origen
       !windows?
     end
   end
+
+  # Blow this cache whenever this file is re-loaded
+  @operating_systems = nil
+
   def self.os
     @operating_systems ||= OperatingSystems.new
   end

data/lib/origen/revision_control.rb

@@ -8,7 +8,7 @@ module Origen
 
     IGNORE_DIRS =  %w(
       .ws .lsf log output web coverage .ref .yardoc .collection .bin
-      .session .bundle .tpc pkg tmp lbin .git
+      .session .bundle .tpc pkg tmp .git
     )
 
     IGNORE_FILES = %w(

data/lib/origen/site_config.rb

@@ -8,7 +8,7 @@ module Origen
     require_relative 'site_config/config'
 
     # Require some useful methods from Origen without requiring the entire module
-    require_relative './boot_api'
+    require_relative 'boot/api'
 
     TRUE_VALUES = ['true', 'TRUE', '1', 1]
     FALSE_VALUES = ['false', 'FALSE', '0', 0]
@@ -428,6 +428,9 @@ module Origen
     end
   end
 
+  # Blow this cache whenever this file is re-loaded
+  @site_config = nil
+
   def self.site_config
     @site_config ||= SiteConfig.new
   end