foreman_fog_proxmox 0.5.6 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b867a431af383a2d626127ab2f79f996bbcc72a8cd770bd94ff48db315270e56
-  data.tar.gz: 38e71818548bea80b97801e50a7153a48cbbc94a17d07f9d555c296c78cccd2c
+  metadata.gz: 1304ab366464cb132705a6d4b31dc6473d52c30e44dd50118d14eb2ef1f64ed6
+  data.tar.gz: 8d3791c5a478031da10323c24fd9f90c2d23dcda0d185dbece4649b5896b26dc
 SHA512:
-  metadata.gz: edf8d6c9b5fb1aa5c1fe4107108435036752a6bd7170545b6ff85d78f086f80c9f6af2dc53c6bca1e0c34418963586f492a5e249a25907c6cc3818e74b8ad6d7
-  data.tar.gz: 6a1ec0442155b270f08ea1fc9ec97e08fff473e624404fd2078c05533f3629bac0bbbafd0ee617ef03732917f378c872bec629c60372d91710d4a6627109b8e5
+  metadata.gz: 9ef6e0f3b3670c18bc5e23d5a467df1df14e041e5036c1bca1bf8de10eb699ffa705e5934da287f6cb42e2baf2730d6a3994fecc396abcbe067941b142e5cf71
+  data.tar.gz: 49d98f70077f0382b046f5763f12fa169c12c5e9e1b57aed84f44b4be18194a5924a75f9ab1f4c46297a400281dfd3036b16e9a8f4df3ff3db0178f41549376f

data/README.md

@@ -12,14 +12,12 @@ It is intended to satisfy this [feature](http://projects.theforeman.org/issues/2
 
 If you like it and need more features you can [support](SUPPORT.md) it.
 
-## Compatibility
+## Compatibility versions
 
-Tested with:
-
-* Foreman >= 1.17 and <= 1.20
-* Fog-proxmox >= 0.5.3
-* Proxmox >= 5.1
-* Ruby >= 2.3
+|Fog-proxmox|Proxmox|Foreman-fog-proxmox|Foreman|Ruby|
+|--|--|--|--|--|
+|<0.6|<5.3|<0.6|<=1.20|>=2.3|
+|>=0.6|=5.3|>=0.6|=1.21|>=2.3|
 
 ## Installation
 
@@ -109,11 +107,11 @@ Redhat, CentOS or Fedora users should also [setup Selinux](https://projects.thef
 
 * Fork this github repo.
 * Clone it on your local machine
-* Install foreman v1.17.3 or later on your machine:
+* Install foreman v1.21.1 on your machine:
 
 ```shell
 git clone https://github.com/theforeman/foreman
-git checkout tags/1.17.3
+git checkout tags/1.21.1
 ```
 
 * Create a Gemfile.local.rb file in foreman/bundler.d/
@@ -142,7 +140,8 @@ cp config/settings.yaml.test config/settings.yaml
 * Install foreman database (sqlite is default in rails development):
 
 ```shell
-cp config/database.yaml.example config/database.yaml
+cp config/model.mappings.example config/model.mappings
+cp config/database.yml.example config/database.yml
 bundle exec bin/rake db:migrate
 bundle exec bin/rake db:seed
 ```
@@ -153,13 +152,22 @@ bundle exec bin/rake db:seed
 bundle exec bin/rake permissions:reset
 ```
 
-* You sholud write tests and you can execute those specific to this plugin:
+* You should write tests and you can execute those specific to this plugin:
+
+all:
 
 ```shell
 export DISABLE_SPRING=true
 bundle exec bin/rake test:foreman_fog_proxmox
 ```
 
+or just one:
+
+```shell
+export DISABLE_SPRING=true
+bundle exec bin/rake test TEST=test/functional/compute_resources_controller_test.rb
+```
+
 * In foreman directory, after you modify foreman_fog_proxmox specific assets (proxmox.js, etc) you have to precompile it:
 
 ```shell
@@ -175,7 +183,7 @@ bundle exec bin/rake plugin:gettext[foreman_fog_proxmox]
 * In foreman directory, run rails server:
 
 ```shell
-rails server
+bundle exec bin/rails server
 ```
 
 * In foreman directory, run in a new terminal the webpack-dev-server:
@@ -184,19 +192,21 @@ rails server
 ./node_modules/.bin/webpack-dev-server --config config/webpack.config.js
 ```
 
+* Or you can launch all together:
+
+```shell
+bundle exec foreman start
+```
+
 See details in [foreman plugin development](https://projects.theforeman.org/projects/foreman/wiki/How_to_Create_a_Plugin)
 
 ## Contributing
 
 You can reach the [contributors](CONTRIBUTORS.md).
-Bug reports and pull requests are welcome on GitHub at [ForemanFogProxmox](https://github.com/theforeman/foreman_fog_proxmox). This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+Bug reports and pull requests are welcome on GitHub at [ForemanFogProxmox](https://github.com/theforeman/foreman_fog_proxmox).
 
-Please read [how to contribute](CONTRIBUTING.md).
+Please read more information about [how to contribute](CONTRIBUTING.md).
 
 ## License
 
 The code is available as open source under the terms of the [GNU Public License v3](LICENSE).
-
-## Code of Conduct
-
-Everyone interacting in the ForemanProxmox project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](CODE_OF_CONDUCT.md).

data/app/controllers/concerns/foreman_fog_proxmox/controller/parameters/compute_resource.rb

@@ -27,7 +27,7 @@ module ForemanFogProxmox
           def compute_resource_params_filter
             super.tap do |filter|   
               filter.permit :ssl_verify_peer,
-                :ssl_certs, :node_name, :disable_proxy
+                :ssl_certs, :node_id, :disable_proxy, :cr_id
             end
           end
 

data/app/helpers/proxmox_container_helper.rb

@@ -28,12 +28,13 @@ module ProxmoxContainerHelper
   GIGA = KILO * MEGA
 
   def parse_container_vm(args)
+    logger.debug("parse_container_vm args=#{args}")
     args = ActiveSupport::HashWithIndifferentAccess.new(args)
     return {} unless args
     return {} if args.empty?
     return {} unless args['type'] == 'lxc'
     config = args['config_attributes']
-    main_a = %w[name type node vmid]
+    main_a = %w[name type node_id vmid interfaces mount_points disks]
     config = args.reject { |key,_value| main_a.include? key } unless config
     ostemplate_a = %w[ostemplate ostemplate_storage ostemplate_file]
     ostemplate = parse_container_ostemplate(args.select { |key,_value| ostemplate_a.include? key })
@@ -45,7 +46,7 @@ module ProxmoxContainerHelper
     memory = parse_container_memory(config.select { |key,_value| memory_a.include? key })
     interfaces_attributes = args['interfaces_attributes']
     networks = parse_container_interfaces(interfaces_attributes)
-    general_a = %w[node name type config_attributes volumes_attributes interfaces_attributes firmware_type provision_method container_volumes server_volumes]
+    general_a = %w[node_id name type config_attributes volumes_attributes interfaces_attributes firmware_type provision_method container_volumes server_volumes]
     logger.debug("general_a: #{general_a}")
     parsed_vm = args.reject { |key,value| general_a.include?(key) || ostemplate_a.include?(key) || ForemanFogProxmox::Value.empty?(value) }
     config_a = []
@@ -151,7 +152,7 @@ module ProxmoxContainerHelper
       nic.store(:rate, args['rate'].to_i) if args['rate']
       nic.store(:tag, args['tag'].to_i) if args['tag']
       logger.debug("parse_container_interface(): add nic=#{nic}")
-      Fog::Proxmox::NicHelper.container_flatten(nic)
+      Fog::Proxmox::NicHelper.flatten(nic)
     end 
   end
 

data/app/helpers/proxmox_server_helper.rb

@@ -28,12 +28,13 @@ module ProxmoxServerHelper
   GIGA = KILO * MEGA
 
   def parse_server_vm(args)
+    logger.debug("parse_server_vm args=#{args}")
     args = ActiveSupport::HashWithIndifferentAccess.new(args)
     return {} unless args
     return {} if args.empty?
     return {} unless args['type'] == 'qemu'
     config = args['config_attributes']
-    main_a = %w[name type node vmid]
+    main_a = %w[name type node_id vmid interfaces mount_points disks]
     config = args.reject { |key,_value| main_a.include? key } unless config
     cdrom_a = %w[cdrom cdrom_storage cdrom_iso]
     cdrom = parse_server_cdrom(config.select { |key,_value| cdrom_a.include? key })
@@ -45,7 +46,7 @@ module ProxmoxServerHelper
     memory = parse_server_memory(config.select { |key,_value| memory_a.include? key })
     interfaces_attributes = args['interfaces_attributes']
     networks = parse_server_interfaces(interfaces_attributes)
-    general_a = %w[node type config_attributes volumes_attributes interfaces_attributes firmware_type provision_method container_volumes server_volumes]
+    general_a = %w[node_id type config_attributes volumes_attributes interfaces_attributes firmware_type provision_method container_volumes server_volumes]
     logger.debug("general_a: #{general_a}")
     parsed_vm = args.reject { |key,value| general_a.include?(key) || ForemanFogProxmox::Value.empty?(value) }
     config_a = []

data/app/helpers/proxmox_vm_helper.rb

@@ -29,10 +29,10 @@ module ProxmoxVmHelper
 
   def object_to_config_hash(vm,type)
     vm_h = ActiveSupport::HashWithIndifferentAccess.new
-    main_a = %w[hostname name type node vmid]
+    main_a = %w[hostname name vmid]
     type = vm.config.attributes['type']
     type = vm.type unless type
-    main = vm.config.attributes.select { |key,_value| main_a.include? key }
+    main = vm.attributes.select { |key,_value| main_a.include? key }
     disks_regexp = /^(scsi|sata|mp|rootfs|virtio|ide)(\d+){0,1}$/
     nics_regexp = /^(net)(\d+)/
     main_a += %w[templated]
@@ -71,11 +71,13 @@ module ProxmoxVmHelper
   end
 
   def remove_deletes(args)
-    args['volumes_attributes'].delete_if { |_key,value| value.has_key? '_delete' }
+    args['volumes_attributes'].delete_if { |_key,value| value.has_key? '_delete' } if args['volumes_attributes']
   end
 
   def convert_memory_size(config_hash, key)
-    config_hash.store(key, (config_hash[key].to_i / MEGA).to_s) unless ForemanFogProxmox::Value.empty?(config_hash[key])
+    # default unit memory size is Mb
+    memory = (config_hash[key].to_i / MEGA).to_s == '0' ? config_hash[key] : (config_hash[key].to_i / MEGA).to_s
+    config_hash.store(key, memory)
   end
 
   def parse_type_and_vmid(uuid)

data/app/models/concerns/fog_extensions/proxmox/{container_config.rb → node.rb}

@@ -17,20 +17,15 @@
 # You should have received a copy of the GNU General Public License
 # along with ForemanFogProxmox. If not, see <http://www.gnu.org/licenses/>.
 
-require 'fog/proxmox/helpers/disk_helper'
-
 module FogExtensions
     module Proxmox
-        module ContainerConfig
+        module Node
             extend ActiveSupport::Concern
-
-            def rootfs_storage
-                mount_points.rootfs.storage
+            def all(options = {})
+                vms = servers.all 
+                vms += containers.all
+                vms
             end
-            def rootfs_file
-                mount_points.rootfs.volid
-            end
-
         end
     end
-end   
+end  

data/app/models/concerns/fog_extensions/proxmox/server.rb

@@ -21,19 +21,8 @@ module FogExtensions
     module Proxmox
         module Server
             extend ActiveSupport::Concern
-            attr_accessor :image_id, :templated, :ostemplate_storage, :ostemplate_file
-            def to_s
-                name
-            end
-            def identity
-                "#{type}_#{vmid}"
-            end
-            def container?
-                type == 'lxc'
-            end
-            def persisted?
-                !!identity && !!uptime
-            end
+            attr_accessor :image_id, :templated, :ostemplate_storage, :ostemplate_file, :password
+            
             def start
                 action('start')
             end

data/app/models/concerns/fog_extensions/proxmox/server_config.rb

@@ -33,16 +33,30 @@ module FogExtensions
                 Fog::Proxmox::CpuHelper.extract_pcid(cpu)
             end
             def cdrom
-                %w[none cdrom].include?(disks.cdrom.volid) ? disks.cdrom.volid : 'image'
+                if disks.cdrom
+                    %w[none cdrom].include?(disks.cdrom.volid) ? disks.cdrom.volid : 'image'
+                else
+                    'none'
+                end
             end
             def cdrom_storage
-                disks.cdrom.storage
+                disks.cdrom ? disks.cdrom.storage : ''
             end
             def cdrom_iso
-                disks.cdrom.volid
+                disks.cdrom ? disks.cdrom.volid : ''
             end
             def cdrom_image
-                %w[none cdrom].include?(disks.cdrom.volid) ? disks.cdrom.volid : 'image'
+                if disks.cdrom
+                    %w[none cdrom].include?(disks.cdrom.volid) ? disks.cdrom.volid : 'image'
+                else
+                    'none'
+                end
+            end
+            def rootfs_storage
+                disks.rootfs.storage if disks.rootfs
+            end
+            def rootfs_file
+                disks.rootfs.volid if disks.rootfs
             end
         end
     end

data/app/models/foreman_fog_proxmox/proxmox.rb

@@ -27,7 +27,7 @@ module ForemanFogProxmox
     validates :url, :format => { :with => URI::DEFAULT_PARSER.make_regexp }, :presence => true
     validates :user, :format => { :with => /(\w+)[@]{1}(\w+)/ }, :presence => true
     validates :password, :presence => true
-    validates :node_name, :presence => true
+    validates :node_id, :presence => true
     before_create :test_connection
 
     def provided_attributes
@@ -49,12 +49,17 @@ module ForemanFogProxmox
     end
 
     def credentials_valid?
-      errors[:url].empty? && errors[:user].empty? && errors[:user].include?('@') && errors[:password].empty? && errors[:node_name].empty?
+      errors[:url].empty? && errors[:user].empty? && errors[:user].include?('@') && errors[:password].empty? && errors[:node_id].empty?
+    end
+
+    def version_suitable?
+      version == '5.3'
     end
 
     def test_connection(options = {})
       super
       credentials_valid?
+      version_suitable?
     rescue => e
       errors[:base] << e.message
       errors[:url] << e.message
@@ -76,7 +81,7 @@ module ForemanFogProxmox
     end
 
     def images_by_storage(type = 'iso', storage_id)
-      storage = node.storages.find_by_id storage_id if storage_id
+      storage = node.storages.get storage_id if storage_id
       storage.volumes.list_by_content_type(type).sort_by(&:volid) if storage
     end
 
@@ -85,7 +90,7 @@ module ForemanFogProxmox
     end
 
     def bridges
-      node = network_client.nodes.find_by_id node_name
+      node = network_client.nodes.get node_id
       bridges = node.networks.all(type: 'any_bridge')
       bridges.sort_by(&:iface)
     end    
@@ -101,15 +106,14 @@ module ForemanFogProxmox
     end
 
     def template(vmid)
-      vm = find_vm_by_uuid("qemu_#{vmid}")
-      vm = find_vm_by_uuid("lxc_#{vmid}") unless vm
-      vm
+      find_vm_by_uuid(vmid)
     end
 
     def host_compute_attrs(host)
       super.tap do |attrs|
         ostype = host.compute_attributes['config_attributes']['ostype']
-        case host.compute_attributes['type']
+        type = host.compute_attributes['type']
+        case type
         when 'lxc'
           host.compute_attributes['config_attributes'].store('hostname',host.name)
         when 'qemu'
@@ -158,13 +162,32 @@ module ForemanFogProxmox
       Fog::Compute::Proxmox::Disk.new(opts)
     end
 
-    def new_interface(attr = {})
+    def new_interface(attr = {}) 
+      type = attr['type']
+      type = 'qemu' unless type
+      case type
+      when 'lxc'
+        return new_container_interface(attr)
+      when 'qemu'
+        return new_server_interface(attr)
+      end
+    end
+
+    def new_server_interface(attr = {})
+      logger.debug("new_server_interface")
       opts = interface_server_defaults.merge(attr.to_h).deep_symbolize_keys
       Fog::Compute::Proxmox::Interface.new(opts)
     end
 
+    def new_container_interface(attr = {})
+      logger.debug("new_container_interface")
+      opts = interface_container_defaults.merge(attr.to_h).deep_symbolize_keys
+      Fog::Compute::Proxmox::Interface.new(opts)
+    end
+
+    # used by host.clone
     def vm_compute_attributes(vm)
-      vm_attrs = vm.attributes.reject { |key,value| [:config].include?(key) || value.to_s.empty? }
+      vm_attrs = vm.attributes.reject { |key,value| [:config, :vmid].include?(key.to_sym) || value.to_s.empty? }
       vm_attrs = set_vm_config_attributes(vm, vm_attrs)
       vm_attrs = set_vm_volumes_attributes(vm, vm_attrs)
       vm_attrs = set_vm_interfaces_attributes(vm, vm_attrs)
@@ -173,15 +196,17 @@ module ForemanFogProxmox
 
     def set_vm_config_attributes(vm, vm_attrs)
       if vm.respond_to?(:config)
-        config = vm.config.attributes.reject { |key,value| [:disks,:mount_points,:interfaces].include?(key) || value.to_s.empty?}
+        config = vm.config.attributes.reject { |key,value| [:disks, :interfaces, :vmid].include?(key) || value.to_s.empty?}
         vm_attrs[:config_attributes] = config
       end
       vm_attrs
     end
 
     def set_vm_volumes_attributes(vm, vm_attrs)
-      volumes = vm.container? ? vm.config.mount_points : vm.config.disks || []
-      vm_attrs[:volumes_attributes] = Hash[volumes.each_with_index.map { |volume, idx| [idx.to_s, volume.attributes] }]
+      if vm.config.respond_to?(:disks)
+        volumes = vm.config.disks || []
+        vm_attrs[:volumes_attributes] = Hash[volumes.each_with_index.map { |volume, idx| [idx.to_s, volume.attributes] }]
+      end
       vm_attrs
     end
 
@@ -194,31 +219,33 @@ module ForemanFogProxmox
     end
 
     def vms(opts = {})
-      node.servers
+      node
     end
 
-    def new_vm(attr = {})
-      attr = ActiveSupport::HashWithIndifferentAccess.new(attr)
-      type = attr['type']
+    def new_vm(new_attr = {})
+      new_attr = ActiveSupport::HashWithIndifferentAccess.new(new_attr)
+      type = new_attr['type']
       type = 'qemu' unless type
       case type
       when 'lxc'
-        vm = new_container_vm(attr)
+        vm = new_container_vm(new_attr)
       when 'qemu'
-        vm = new_server_vm(attr)
+        vm = new_server_vm(new_attr)
       end
       logger.debug(_("new_vm() vm.config=%{config}") % { config: vm.config.inspect })
       vm
     end
 
-    def new_container_vm(attr = {})
-      vm = node.containers.new(vm_container_instance_defaults.merge(parse_container_vm(attr.merge(type: 'lxc'))))
+    def new_container_vm(new_attr = {})
+      new_attr.merge(node_id: node_id)
+      vm = node.containers.new(parse_container_vm(vm_container_instance_defaults.merge(new_attr.merge(type: 'lxc'))).deep_symbolize_keys)
       logger.debug(_("new_container_vm() vm.config=%{config}") % { config: vm.config.inspect })
       vm
     end
 
-    def new_server_vm(attr = {})
-      vm = node.servers.new(vm_server_instance_defaults.merge(parse_server_vm(attr.merge(type: 'qemu'))))
+    def new_server_vm(new_attr = {})
+      new_attr.merge(node_id: node_id)
+      vm = node.servers.new(parse_server_vm(vm_server_instance_defaults.merge(new_attr.merge(type: 'qemu'))).deep_symbolize_keys)
       logger.debug(_("new_server_vm() vm.config=%{config}") % { config: vm.config.inspect })
       vm
     end
@@ -235,20 +262,17 @@ module ForemanFogProxmox
         clone = node.servers.get vmid
         clone.update(name: args[:name])        
       else
-        logger.debug(_("create_vm(): %{args}") % { args: args })
         convert_sizes(args)
         remove_deletes(args)
         case type
           when 'qemu'
-            node.servers.create(parse_server_vm(args))
+            vm = node.servers.create(parse_server_vm(args))
           when 'lxc'
             hash = parse_container_vm(args)
             hash = hash.merge(vmid: vmid)
-            node.containers.create(hash.reject { |key,_value| %w[ostemplate_storage ostemplate_file].include? key })
+            vm = node.containers.create(hash.reject { |key,_value| %w[ostemplate_storage ostemplate_file].include? key })
         end
       end
-      vm = find_vm_by_uuid("#{type}_#{vmid}")
-      vm
     rescue => e
       logger.warn(_("failed to create vm: %{e}") % { e: e })
       destroy_vm vm.id if vm
@@ -256,16 +280,23 @@ module ForemanFogProxmox
     end
 
     def find_vm_by_uuid(uuid)
-      type, vmid = parse_type_and_vmid(uuid)
-      case type
-      when 'qemu'
-        node.servers.get(vmid)
-      when 'lxc'
-        node.containers.get(vmid)
+      begin
+        vm = node.servers.get(uuid)
+      rescue Fog::Errors::NotFound
+        vm = nil  
+      rescue Fog::Errors::Error => e
+        Foreman::Logging.exception(_("Failed retrieving proxmox server vm by vmid=%{uuid}") % { vmid: uuid }, e)
+        raise(ActiveRecord::RecordNotFound)
+      end
+      begin
+        vm = node.containers.get(uuid) unless vm
+      rescue Fog::Errors::NotFound
+        vm = nil  
+      rescue Fog::Errors::Error => e
+        Foreman::Logging.exception(_("Failed retrieving proxmox container vm by vmid=%{uuid}") % { vmid: uuid }, e)
+        raise(ActiveRecord::RecordNotFound)
       end
-    rescue Fog::Errors::Error => e
-      Foreman::Logging.exception(_("Failed retrieving proxmox vm by vmid=%{vmid} and type=%{type}") % { vmid: vmid, type: type }, e)
-      raise(ActiveRecord::RecordNotFound)
+      vm
     end
 
     def supports_update?
@@ -295,41 +326,35 @@ module ForemanFogProxmox
     end
 
     def image_exists?(image)
-      vm = find_vm_by_uuid("qemu_#{image}")
-      vm = find_vm_by_uuid("lxc_#{image}") unless vm
-      vm!=nil
+      !find_vm_by_uuid(image).nil?
     end
 
-    def save_vm(uuid, attr)
-      type, vmid = parse_type_and_vmid(uuid)
-      attr = attr.merge(type: type, vmid: vmid)
+    def save_vm(uuid, new_attributes)
       vm = find_vm_by_uuid(uuid)
-      logger.debug(N_("save_vm(): %{attr}") % { attr: attr })
-      templated = attr[:templated]
+      templated = new_attributes[:templated]
       if (templated == '1' && !vm.templated?)
-        vm.template
+        vm.create_template
       else
-        parsed_attr = vm.container? ? parse_container_vm(attr) : parse_server_vm(attr)
-        merged = vm.config.attributes.merge(parsed_attr.symbolize_keys).deep_symbolize_keys
-        filtered = merged.reject { |key,value| [:node,:vmid,:type,:templated,:image_id].include?(key) || value.to_s.empty? }
-        vm.update(filtered)
+        parsed_attr = vm.container? ? parse_container_vm(new_attributes.merge(type: vm.type)) : parse_server_vm(new_attributes.merge(type: vm.type))
+        vm.update(parsed_attr.reject { |key,value| [:templated,:ostemplate,:ostemplate_file,:ostemplate_storage].include? key.to_sym || ForemanFogProxmox::Value.empty?(value) })
       end
+      vm = find_vm_by_uuid(uuid)
     end
 
     def next_vmid
       node.servers.next_id
     end
 
-    def node_name  
-      self.attrs[:node_name]
+    def node_id  
+      self.attrs[:node_id]
     end
 
-    def node_name=(value)
-      self.attrs[:node_name] = value
+    def node_id=(value)
+      self.attrs[:node_id] = value
     end
 
     def node
-      client.nodes.find_by_id node_name
+      client.nodes.get node_id
     end
 
     def ssl_certs  
@@ -370,9 +395,14 @@ module ForemanFogProxmox
 
     def console(uuid)
       vm = find_vm_by_uuid(uuid)
-      type_console = vm.config.type_console
       options = {}
-      options.store(:websocket, 1) if type_console == 'vnc'
+      if vm.container?
+        type_console = 'vnc'
+        options.store(:console, type_console)
+      else
+        type_console = vm.config.type_console
+      end
+        options.store(:websocket, 1) if type_console == 'vnc'
       begin
         vnc_console = vm.start_console(options)  
         WsProxy.start(:host => host, :host_port => vnc_console['port'], :password => vnc_console['ticket']).merge(:name => vm.name, :type => type_console)
@@ -382,6 +412,10 @@ module ForemanFogProxmox
       end
     end
 
+    def version
+      identity_client.read_version
+    end
+
     private
 
     def fog_credentials
@@ -417,7 +451,7 @@ module ForemanFogProxmox
         name: "foreman_#{Time.now.to_i}",
         vmid: next_vmid, 
         type: 'qemu', 
-        node: node.to_s, 
+        node_id: node_id, 
         cores: 1, 
         sockets: 1, 
         kvm: 0,
@@ -428,7 +462,7 @@ module ForemanFogProxmox
         cpu: 'kvm64',
         scsihw: 'virtio-scsi-pci',
         ide2: "none,media=cdrom",
-        templated: 0).merge(Fog::Proxmox::DiskHelper.flatten(volume_server_defaults)).merge(Fog::Proxmox::DiskHelper.flatten(volume_container_defaults)).merge(Fog::Proxmox::NicHelper.flatten(interface_server_defaults))
+        templated: 0).merge(Fog::Proxmox::DiskHelper.flatten(volume_server_defaults)).merge(Fog::Proxmox::DiskHelper.flatten(volume_container_defaults)).merge(Fog::Proxmox::NicHelper.flatten(interface_defaults))
     end
 
     def vm_container_instance_defaults
@@ -436,30 +470,34 @@ module ForemanFogProxmox
         name: "foreman_#{Time.now.to_i}",
         vmid: next_vmid, 
         type: 'lxc', 
-        node: node.to_s,
+        node_id: node_id, 
         memory: 512 * MEGA, 
-        templated: 0).merge(Fog::Proxmox::DiskHelper.flatten(volume_server_defaults)).merge(Fog::Proxmox::DiskHelper.flatten(volume_container_defaults)).merge(Fog::Proxmox::NicHelper.container_flatten(interface_container_defaults))
+        templated: 0).merge(Fog::Proxmox::DiskHelper.flatten(volume_container_defaults)).merge(Fog::Proxmox::DiskHelper.flatten(volume_server_defaults)).merge(Fog::Proxmox::NicHelper.flatten(interface_defaults))
     end
 
     def vm_instance_defaults
-      super.merge(vmid: next_vmid, node: node.to_s)
+      super.merge(vmid: next_vmid, node_id: node_id)
     end
 
     def volume_server_defaults(controller = 'scsi', device = 0)
       id = "#{controller}#{device}"
-      { id: id, storage: storages.first.to_s, size: (8 * GIGA), options: { cache: 'none' } }
+      { id: id, storage: storages.first.identity.to_s, size: (8 * GIGA), options: { cache: 'none' } }
     end
 
     def volume_container_defaults(id='rootfs')
-      { id: id, storage: storages.first.to_s, size: (8 * GIGA), options: {  } }
+      { id: id, storage: storages.first.identity.to_s, size: (8 * GIGA), options: {  } }
+    end
+
+    def interface_defaults(id = 'net0')
+      { id: id, model: 'virtio', name: 'eth0', bridge: bridges.first.identity.to_s }
     end
 
     def interface_server_defaults(id = 'net0')
-      { id: id, model: 'virtio', bridge: bridges.first.to_s }
+      { id: id, model: 'virtio', bridge: bridges.first.identity.to_s }
     end
 
     def interface_container_defaults(id = 'net0')
-      { id: id, name: 'eth0', bridge: bridges.first.to_s }
+      { id: id, name: 'eth0', bridge: bridges.first.identity.to_s }
     end
     
     def compute_os_types(host)