vagrant-gpii-ci 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f84a3bc955514289f984de6bd5b4b18f42e31ca6
-  data.tar.gz: a794a423590916f864c43d5b870a5c2438f45e3e
+  metadata.gz: 34f333fe7dab9d5a9d7cce696ee92c0393b9edd1
+  data.tar.gz: 5a57b071b54babf95d35a9783b270c0ebcaee40d
 SHA512:
-  metadata.gz: 164d38c4cc0b4d7c92f3dde9180cf06dba4fba575a188cb1b1a13cf84457988e63cc940116793bd58c2f690da87e8b03674a2c82e85cbcb191fc9331ee326bf8
-  data.tar.gz: 529c4a02a5f24b8fb52f68f0dffdabcf26c81493aab6b5fba9f5c458cc8be04145bb4a1b6dbce8fc0dd8f69310537571d8d8a9c94cd8e6b00883606cf062139c
+  metadata.gz: 805f875edb7a29b3c945932e0b4231faafa3a50db67b60fce0f6acee146666fad1ece7f96343bfba2fc041356def697e9d32dae748663e31b6d24c1ebe16ef2f
+  data.tar.gz: 6c7d40583bff99bbde2f97241987df40836005fc090730ab9a6db63b2cc98097db69a522c587f73cbf01df0d12dca64dc280d833f50bd1955a2252ea305100e0

data/README.md

@@ -1,94 +1,76 @@
-Vagrant-vmenv
+Vagrant-GPII-CI
 =============
 
-Vagrant-vmenv is a npm module that is used to extend the behavior of a
-Vagrantfile. It uses virtual machine definitions to spin up complete
+Vagrant-GPII-CI is a vagrant plugin that is used to simplify the configuration stored in a Vagrantfile. It uses virtual machine definitions to spin up complete
 enviroments where you can run tests or run your code.
 
 Installation
 ------------
 
 ```
-npm install -g http://github.com/amatas/vagrant-vmenv
-cp node_modules/vagrant-vmenv/Vagrantfile.template Vagrantfile
-cp node_modules/vagrant-vmenv/qi.yml.template .qi.yml
+vagrant plugin install vagrant-gpii-ci
 ```
 
-The Vagrantfile acts as a pointer to the module, it shouldn't be modified. If
-you want to make a change at the environment level do so in the [environment
-configuration file](envs/), and if you want to configure how the applications
-are deployed and tested do so in the [.qi.yml](qi.yml.template) file of your
-repository.
-
 Working with vms
 ----------------
 
+No Vagrantfile is required if a file [.gpii-ci.yml](gpii-ci.yml.template) is found in the root of the repository.
+
+The name of the file can be override using the environment variable `VAGRANT_CI_FILE`.
+
 Commands:
 
- * `vagrant up` to spin up the [environment](envs/) defined in the .qi.yml file.
- * `vagrant destroy` to stop and destroy the vm.
- * `vagrant halt` to shutdown the vm without destroy it.
+ * `vagrant up [vm]` to spin up the defined in the .ci_env variable of the [.gpii-ci.yml](gpii-ci.yml.template) file. 
+ * `vagrant destroy [vm]` to stop and destroy the vm.
+ * `vagrant reload [vm]` to stop and destroy the vm.
+ * `vagrant halt [vm]` to shutdown the vm without destroy it.
+ * `vagrant ci test [vm]` to run all the stages defined in the selected vm
+
 
 Note:
 
- * `vagrant up` will exec the commands listed in the *setup* variable of each
-application listed in the .qi.yml file.
- * `vagrant provision` will exec the commands listed in the *test_cmds* variable
-of each application listed in the .qi.yml file.
+ * The `vm` parameter is not necessary in environments with only one VM defined.
 
-Networking
-----------
+Sample:
 
-A VM can have multiple virtual NICs. Two types are avilable for each NIC: public
-and private. The public NICs will be attached to the host's physical network,
-the private NICs will be attached to a private network only visible between the
-other VMs and the host. The IP address of a private network can be customized in
-the definition of the VM. An example of the network definition of a VM can be:
 
 ```
-networks:
-  privatenet:
-    type: private
-    ip: 192.168.45.22
-  publicnet:
-    type: public
+.ci_env:
+  default: &default
+    cpu: 2                   # number of cpus
+    memory: 2048             # amount of RAM memory
+    clone: true              # use the linked_clone Vagrant feature
+    autostart: false         # only start a VM when it's specfied in the command line
+  vms:
+    windows10:               # name of the VM
+      <<: *default           # referece of the common part
+      3d: true               # enable 3D acceleration
+      sound: true            # add a sound card to the VM
+      box: inclusivedesign/windows10-eval
+    windows81:               # name of the VM
+      <<: *default           # referece of the common part
+      box: inclusivedesign/windows81-eval-x64
+    windows7:                # name of the VM
+      <<: *default           # referece of the common part
+      box: inclusivedesign/windows7-eval-x64
 ```
 
-If an environment has multiple VMs definitions with several NICs the *hosts*
-file of each VM will list all the IP address of each VM plus the name of the VM,
-this is very useful to point services between the VMs.
-
-Forwarded ports
----------------
+Networking
+----------
 
-The port forwarding is configured in the VMs definition. The `guest_port`
-variable is the source port to be mapped to the `host_port` variable. The
-`guest_port` must be set in each port forward block, `host_port` and protocol are
-optionals.
+All the VMs have access to Internet using the gateway of the host through a NAT interface.
 
-```
-ports:
-  - guest_port: 8080
-    host_port: 8888
-    protocol: tcp
-  - guest_port: 8181
-    host_port: 9999
-  - guest_port:8081
-```
+In the case of multi VM environments, a additional NIC card is create in each VM with a private IP of a private network that all the VMs share. The IP range of this network is 192.168.50.0/24. The IP address are assigned to each VM starting by 10.
 
-Shared folders
---------------
+Mapped ports
+---------------
 
-Each application can use a shared folder. If the *folder* variable of the
-application has a *src* key, Vagrant will map the path set in the src folder of
-the host to the path set in the *dest* variable in the VM.
+The port mapping is configured in the VMs definition. The `mapped_ports`
+variable is a list of ports that will be mapped from the VM to the host.
 
 ```
-folder:
-  src: "."
-  dest: "/app/universal"
+mapped_ports:
+  - 8080
+  - 8181
 ```
 
-More samples definitions can be found either in the [envs](envs) directory or in
-the [qi.yml.template](qi.yml.template).
-

data/gpii-ci.yml.template

@@ -0,0 +1,44 @@
+---
+
+# The variables that start with a dot "." are ignored by gitlab-ci, 
+# but they are used by the vagrant-gpii-ci plugin
+#
+# .ci_env variable defines the settings of each VM. The common variables are in 
+# the section 'default' which will be reference later in each VM definition.
+
+.ci_env:
+  default: &default
+    cpu: 2                   # number of cpus
+    memory: 2048             # amount of RAM memory
+    clone: true              # use the linked_clone Vagrant feature
+    autostart: false         # only start the VM specfied in the command line
+  vms:
+    windows10:               # name of the VM
+      <<: *default           # referece of the common part
+      box: inclusivedesign/windows10-eval
+    windows81:               # name of the VM
+      <<: *default           # referece of the common part
+      box: inclusivedesign/windows81-eval-x64
+    windows7:                # name of the VM
+      <<: *default           # referece of the common part
+      box: inclusivedesign/windows7-eval-x64
+
+stages:                # Stages to perform when 'ci test' command is invoked
+  - setup              # name of the first stage to execute
+  - test               # name of the second stage to execute
+
+setup_job:
+  stage: setup         # name of the stage
+  script:              # Only one multiline script to execute
+    - |
+      choco upgrade firefox googlechrome -y
+      $moduleLocation = Join-Path $env:SystemDrive "vagrant/provisioning/Provisioning.psm1"
+      $destinationDir = Join-Path $env:SystemDrive "tmp"
+      cp $moduleLocation $destinationDir
+test_job:
+  stage: test          # name of the stage
+  script:              # One line per command to execute
+    - provisioning/Chocolatey.ps1
+    - provisioning/Npm.ps1
+    - provisioning/Build.ps1
+    - provisioning/Installer.ps1

data/lib/vagrant-gpii-ci/action/build_vagrantfile.rb

@@ -0,0 +1,160 @@
+require 'yaml'
+
+module VagrantPlugins
+  module GPIICi
+    module Action
+      class BuildVagrantfile
+
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          @env = env
+
+          # The file .gpii-ci.yml can be override using this environment variable
+          ci_file ||= ENV["VAGRANT_CI_FILE"] if ENV.key?("VAGRANT_CI_FILE")
+          ci_file ||= ".gpii-ci.yml"
+
+          # Only if the ci_file is found the plugin will run
+          if File.exist?(project_home(@env).join(ci_file)) 
+          
+            environment = @env[:env]
+            ci_definition = get_ci_definition (ci_file)
+            environment.instance_variable_set(:@ci_tests, get_ci_tests(ci_definition))
+            vagrantfile_proc = Proc.new do
+              Vagrant.configure(2) do |config|
+                build_vms_config(config, get_ci_environment(ci_definition))
+              end 
+            end
+
+            # The Environment instance has been instantiated without a Vagrantfile
+            # that means that we need to store some internal variables and 
+            # instantiate again the Vagrantfile instance with our previous code.
+            environment.instance_variable_set(:@root_path, project_home(@env))
+            environment.instance_variable_set(:@local_data_path, vagrant_home(@env))
+            # the cienv code will be the first item to check in the list of
+            # Vagrantfile sources
+            config_loader = environment.config_loader
+            config_loader.set(:cienv, vagrantfile_proc.call)
+            environment.instance_variable_set(:@vagrantfile, Vagrant::Vagrantfile.new(config_loader, [:cienv, :home, :root]))
+
+          end
+          @app.call(env)
+        end
+
+        def vagrant_home(env)
+          project_home(env).join(Vagrant::Environment::DEFAULT_LOCAL_DATA)
+        end
+
+        def project_home(env)
+          environment = env[:env]
+          environment.instance_variable_get(:@cwd)  
+        end
+
+        def get_ci_tests(definition)
+          ci_tests = {}
+          definition[".ci_env"]["vms"].each do | vmname, vmdetails |
+
+            ci_tests["#{vmname}"] = {}
+            ci_tests["#{vmname}"]["shell"] = {}
+            definition["stages"].each do |stage|
+              definition.each do |stagename, stagecontent|
+                # Ignore the statements that start with a dot
+                next if stagename.start_with?(".") or stagename.eql?("stages") or not stagecontent["stage"].eql?(stage)
+                # Build the hash of tests for each VM
+                if stagecontent.include?("stage")
+                  if vmdetails.include?("tags") and stagecontent.include?("tags")
+                    ci_tests["#{vmname}"]["shell"][stagecontent["stage"]] = stagecontent["script"] \
+                      if not (stagecontent["tags"] & vmdetails["tags"]).empty?
+                  elsif not stagecontent.include?("tags")
+                    ci_tests["#{vmname}"]["shell"][stagecontent["stage"]] = stagecontent["script"]
+                  else
+                    next
+                  end  
+                end
+              end
+            end
+          end
+          ci_tests
+        end
+
+        def get_ci_definition(definition_file)
+          # load the definition file
+          ci_file = File.expand_path(project_home(@env).join(definition_file))
+          @ci_definition = YAML.load(File.read(ci_file))
+        end
+
+        # In the case of a multiVM environment, we need to connect the VMs using 
+        # a private network
+        def inject_private_network_config(ci_environment_vms)
+          return ci_environment_vms if ci_environment_vms.count() == 1
+          int_id = 10
+          ci_environment_vms.each do |vm,config|
+            ci_environment_vms[vm]["private_ip"] = "192.168.50." + int_id.to_s
+            int_id += 1
+          end
+          ci_environment_vms
+        end
+        def get_ci_environment(definition)
+          ci_environment_vms = inject_private_network_config(definition[".ci_env"]["vms"])
+          #TODO: load additional yaml files to extend the definition of the vms
+        end
+
+        # Setup the provider using the definition of each VM.
+        def set_provider_config(vm_instance, ci_vm_definition)
+      
+          vm_instance.vm.provider :virtualbox do |vm|
+      
+            vm.linked_clone = ci_vm_definition["clone"] || false
+            
+            vm.customize ["modifyvm", :id, "--memory", ci_vm_definition["memory"] ]
+            vm.customize ["modifyvm", :id, "--cpus", ci_vm_definition["cpu"] ]
+      
+            if ci_vm_definition["3d"] == true then
+              vm.customize ["modifyvm", :id, "--vram", "128"]
+              vm.customize ["modifyvm", :id, "--accelerate3d", "on"]
+            end
+            
+            if ci_vm_definition["sound"] == true then
+              vm.customize ["modifyvm", :id, "--audio", "null", "--audiocontroller", "hda"]
+            end
+      
+            vm.customize ["modifyvm", :id, "--ioapic", "on"]
+            vm.customize ["setextradata", "global", "GUI/SuppressMessages", "all"]
+      
+            vm.gui = ci_vm_definition["gui"] || true
+          end
+      
+          vm_instance.vm.box = ci_vm_definition["box"]
+        
+        end
+
+        def set_network_config(vm_instance, ci_vm_definition)
+          vm_instance.vm.network :private_network, ip: ci_vm_definition["private_ip"] if ci_vm_definition["private_ip"]
+          ci_vm_definition["mapped_ports"].each do |port|
+            vm_instance.vm.network "forwarded_port",
+            guest: port,
+            host: port,
+            protocol: "tcp",
+            auto_correct: true
+          end if ci_vm_definition["mapped_ports"]
+        end
+
+        def build_vms_config(vagrant_config, ci_environment_vms)
+          ci_environment_vms.each do |ci_vm_id, ci_vm_definition|
+
+            ci_autostart = true
+            ci_autostart = ci_vm_definition["autostart"] if ci_vm_definition.key?("autostart")
+
+            vagrant_config.vm.define ci_vm_id, autostart: ci_autostart do |vm_instance|
+                  vm_instance.vm.hostname = ci_vm_id
+                  set_provider_config(vm_instance, ci_vm_definition)
+                  set_network_config(vm_instance, ci_vm_definition)
+            end
+          end
+        end
+      end
+    end
+  end
+end     

data/lib/vagrant-gpii-ci/action/init_environment.rb

@@ -1,20 +1,19 @@
 require "log4r"
 
 module VagrantPlugins
-  module Cienv
-    module Action
-
-      # This action sets up the QI QI environment
-      class InitEnvironment
+  module GPIICi
+    module Command
+      # This action sets up the GPII CI environment
+      class InitEnvironment < Vagrant.plugin("2", :command)
 
         def initialize(app, env)
           @app = app
-          @logger = Log4r::Logger.new("vagrant_qi::action::init_environment")
+          @logger = Log4r::Logger.new("VagrantPlugins::GPIICi::action::init_environment")
         end
 
         def call(env)
-          puts "i am inside class InitEnvironment"
-          @logger.info('i am inside class InitEnvironment - call()')
+          @logger.info('This call does nothing yet')
+          #TODO: Create a .qi.yml file based on a template
           @app.call(env)
         end
 

data/lib/vagrant-gpii-ci/action/update_hosts.rb

@@ -0,0 +1,138 @@
+module VagrantPlugins
+  module GPIICi
+    module Action
+      class UpdateHosts
+
+        def initialize(app, env)
+          @global_env = global_env
+          @config = Util.get_config(@global_env)
+          @provider = provider
+          @logger = Log4r::Logger.new('vagrant::hostmanager::updater')
+          @logger.debug("init updater")
+        end
+
+        def update_guest(machine)
+          return unless machine.communicate.ready?
+
+          if machine.config.vm.communicator == :winrm
+            windir = ""
+            machine.communicate.execute("echo %SYSTEMROOT%", {:shell => :cmd}) do |type, contents|
+              windir << contents.gsub("\r\n", '') if type == :stdout
+            end
+            realhostfile = "#{windir}\\System32\\drivers\\etc\\hosts.tmp"
+          else
+            realhostfile = '/tmp/hosts'
+          end
+          # download and modify file with Vagrant-managed entries
+          file = @global_env.tmp_path.join("hosts.#{machine.name}")
+          machine.communicate.download(realhostfile, file)
+
+          @logger.debug("file is: #{file.to_s}")
+          @logger.debug("class of file is: #{file.class}")
+
+          if update_file(file, machine, false)
+            if windir
+              machine.communicate.sudo("mv -force /tmp/hosts/hosts.#{machine.name} #{realhostfile}")
+            else
+              machine.communicate.sudo("cat /tmp/hosts >> #{realhostfile}")
+            end
+          end
+
+        end
+
+        private
+
+        def update_file(file, resolving_machine = nil, include_id = true)
+          file = Pathname.new(file)
+          old_file_content = file.read
+          new_file_content = update_content(old_file_content, resolving_machine, include_id)
+          file.open('wb') { |io| io.write(new_file_content) }
+          old_file_content != new_file_content
+        end
+
+        def update_content(file_content, resolving_machine, include_id)
+          id = include_id ? " id: #{read_or_create_id}" : ""
+          header = "## vagrant-hostmanager-start#{id}\n"
+          footer = "## vagrant-hostmanager-end\n"
+          body = get_machines
+            .map { |machine| get_hosts_file_entry(machine, resolving_machine) }
+            .join
+          get_new_content(header, footer, body, file_content)
+        end
+
+        def get_hosts_file_entry(machine, resolving_machine)
+          ip = get_ip_address(machine, resolving_machine)
+          host = machine.config.vm.hostname || machine.name
+          aliases = machine.config.hostmanager.aliases
+          if ip != nil
+            "#{ip}\t#{host}\n" + aliases.map{|a| "#{ip}\t#{a}"}.join("\n") + "\n"
+          end
+        end
+
+        def get_ip_address(machine, resolving_machine)
+          custom_ip_resolver = machine.config.hostmanager.ip_resolver
+          if custom_ip_resolver
+            custom_ip_resolver.call(machine, resolving_machine)
+          else
+            ip = nil
+            if machine.config.hostmanager.ignore_private_ip != true
+              machine.config.vm.networks.each do |network|
+                key, options = network[0], network[1]
+                ip = options[:ip] if key == :private_network
+                break if ip
+              end
+            end
+            ip || (machine.ssh_info ? machine.ssh_info[:host] : nil)
+          end
+        end
+
+        def get_machines
+          if @config.hostmanager.include_offline?
+            machines = @global_env.machine_names
+          else
+            machines = @global_env.active_machines
+              .select { |name, provider| provider == @provider }
+              .collect { |name, provider| name }
+          end
+          # Collect only machines that exist for the current provider
+          machines.collect do |name|
+                begin
+                  machine = @global_env.machine(name, @provider)
+                rescue Vagrant::Errors::MachineNotFound
+                  # ignore
+                end
+                machine
+              end
+            .reject(&:nil?)
+        end
+
+        def get_new_content(header, footer, body, old_content)
+          if body.empty?
+            block = "\n"
+          else
+            block = "\n\n" + header + body + footer + "\n"
+          end
+          # Pattern for finding existing block
+          header_pattern = Regexp.quote(header)
+          footer_pattern = Regexp.quote(footer)
+          pattern = Regexp.new("\n*#{header_pattern}.*?#{footer_pattern}\n*", Regexp::MULTILINE)
+          # Replace existing block or append
+          old_content.match(pattern) ? old_content.sub(pattern, block) : old_content.rstrip + block
+        end
+
+        def read_or_create_id
+          file = Pathname.new("#{@global_env.local_data_path}/hostmanager/id")
+          if (file.file?)
+            id = file.read.strip
+          else
+            id = SecureRandom.uuid
+            file.dirname.mkpath
+            file.open('w') { |io| io.write(id) }
+          end
+          id
+        end
+      end
+    end
+  end
+end
+

data/lib/vagrant-gpii-ci/action.rb

@@ -1,11 +1,8 @@
 require "pathname"
-require 'json'
-require 'yaml'
-
 require "vagrant/action/builder"
 
 module VagrantPlugins
-  module Cienv
+  module GPIICi
     module Action
       # Include the built-in modules so we can use them as top-level things.
       include Vagrant::Action::Builtin
@@ -16,107 +13,17 @@ module VagrantPlugins
         end
       end
 
+      def self.build_vagrantfile
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use BuildVagrantfile
+        end
+      end
+
       # The autoload farm
       action_root = Pathname.new(File.expand_path("../action", __FILE__))
       autoload :InitEnvironment, action_root.join("init_environment")
+      autoload :BuildVagrantfile, action_root.join("build_vagrantfile")
 
-      class BuildVagrantfile
-
-        def gem_path
-          Pathname.new(File.dirname __dir__)
-        end
-
-        def project_home
-          environment = @env[:env]
-          environment.instance_variable_get(:@cwd)  
-        end
-
-        def vagrant_home
-          project_home.join(Vagrant::Environment::DEFAULT_LOCAL_DATA)
-        end
-
-        def initialize(app, env)
-          @app = app
-          @env = env
-          environment = @env[:env]
-
-          # Only make all the magic if the .qi.yml definition file is found
-          return if !File.exist?(project_home.join(".qi.yml"))
-
-          require_relative "config/config_provider.rb"
-          require_relative "config/config_provision.rb"
-          require_relative "config/config_network.rb"
-          require_relative "config/config_folders.rb"
-
-          # $vagrant_vmenv_path = vagrant_home.to_s + "/provision-ci/"
-
-          # load the .qi.yml file
-          qi_file = File.expand_path (project_home.join(".qi.yml"))
-          qi_definition = YAML.load(File.read(qi_file))
-
-          # Copy enviroments and playbooks to home dir if needed
-          FileUtils.mkdir(vagrant_home) if !File.exist?(vagrant_home)
-          FileUtils.mkdir(vagrant_home.join('provision-ci')) if !File.exist?(vagrant_home.join('provision-ci'))
-          FileUtils.cp_r(gem_path.join('envs'), vagrant_home.join('provision-ci/envs')) if !File.exist?(vagrant_home.join('provision-ci/envs'))
-          FileUtils.cp_r(gem_path.join('provisioning'), vagrant_home.join('provision-ci/provisioning')) if !File.exist?(vagrant_home.join('provision-ci/provisioning'))
-
-          # load the environment based on "env_runtime" variable of .qi.yml
-          vagrant_env = qi_definition["env_runtime"] || "default"
-          environment_file = File.expand_path(vagrant_home.to_s + "/provision-ci/envs", File.dirname(__FILE__)) +
-                             File::SEPARATOR + vagrant_env
-          if File.exists?(environment_file + ".json")
-            environment_ci = JSON.parse(File.read(environment_file + ".json"))
-          elsif File.exists?(environment_file + ".yml")
-            environment_ci = YAML.load(File.read(environment_file + ".yml"))
-          else
-            raise "Environment_ci config file not found, see envs directory\n #{environment_file}"
-          end
-
-          # build the host list of the VMs used, very useful to allow the communication
-          # between them based on the hostname and IP stored in the hosts file
-          build_hosts_list(environment_ci["vms"])
-
-          vagrantfile_proc = Proc.new do
-            Vagrant.configure(2) do |config|
-
-              environment_ci["vms"].each do |vm_id, vm_config|
-
-                config.vm.define vm_id, autostart: vm_config["autostart"] do |instance|
-
-                  # Ansible handles this task better than Vagrant
-                  #instance.vm.hostname = vm_id
-
-                  config_provider(instance, vm_config, environment_ci["global"])
-
-                  config_provision(instance, vm_config, vm_id, qi_definition["apps"], vagrant_home.join('provision-ci').to_s)
-
-                  config_network(instance, vm_config)
-
-                  config_folders(instance, vm_id, qi_definition["apps"], vagrant_home.join('provision-ci').to_s)
-
-                end
-              end
-            end 
-          end
-
-          # The Environment instance has been instantiated without a Vagrantfile
-          # that means that we need to store some internal variables and 
-          # instantiate again the Vagrantfile instance with our previous code.
-
-          environment.instance_variable_set(:@root_path, project_home)
-          environment.instance_variable_set(:@local_data_path, vagrant_home) 
-
-          # the cienv code will be the first item to check in the list of
-          # Vagrantfile sources
-          config_loader = environment.config_loader
-          config_loader.set(:cienv, vagrantfile_proc.call)
-          environment.instance_variable_set(:@vagrantfile, Vagrant::Vagrantfile.new(config_loader, [:cienv, :home, :root]))
-          
-        end
-        def call(env)
-          @app.call(env)
-        end
-      end
     end
   end
 end

data/lib/vagrant-gpii-ci/command/base.rb

@@ -1,7 +1,7 @@
 require "vagrant/plugin/state_file"
 
 module VagrantPlugins
-  module Cienv
+  module GPIICi
     module Command
       class Base < Vagrant.plugin("2", :command)
         # This is a helper for executing an action sequence with the proper