fog-proxmox 0.16.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4cdecf83035e83be1e7ceb19a56e551e65c0761ec0330ddfc23c834dccdf369c
-  data.tar.gz: 7469eec6715cb9210eff2da78364d8b8d67a24fc7e4bb52dd809b5202135eb79
+  metadata.gz: 2a248dd1c4522b48cddfef2eccd5d07ee1c888fd72460ec333390e71b81803b5
+  data.tar.gz: 3ba917b2e4ae32138edabc4abc8cd65d5248eb6404f367bb11cd61a4c7395180
 SHA512:
-  metadata.gz: 9588e62afafb53c22eac52bca2bc65d3e9c9adab8445fa2afa41c97b9933b0bcb49680f6a099df2c2f8ea8be1b5f270064e864991beb46cafdd7a949f3d5c28f
-  data.tar.gz: e96d35aa10121df4325f45908276e65af1413d900e508b7d9064cae608f74dc0033886a80e139eac313114e93e6ff7a2215f2282739b660ce4a5ebff0a6c67ef
+  metadata.gz: 962ebb8637afce2db9c75156efcaf0d296c41b9027f881824bc096046016077126c2efd498caa346fa3837310d42a67ae0dfba7854124b9664c36b520f073044
+  data.tar.gz: a13abbba5806fd3414a52cfac3fb684c596eb7cd9edec744813274d41ca1afdf4d0e69e8d136ba9407691e60d24de4f2991f93aa2687186dadabdb4b13c6f726

data/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## [1.0.0](https://github.com/fog/fog-proxmox/compare/v0.16.2...v1.0.0) (2026-09-14)
+
+
+### ⚠ BREAKING CHANGES
+
+* Add support for ISO uploads via Proxmox API ([#148](https://github.com/fog/fog-proxmox/issues/148))
+
+### Features
+
+* Add support for ISO uploads via Proxmox API ([#148](https://github.com/fog/fog-proxmox/issues/148)) ([396d08c](https://github.com/fog/fog-proxmox/commit/396d08c573feceda8443072d2c76cffd3c2a4918))
+
+
+### Bug Fixes
+
+* RuboCop extra spacing offenses ([#149](https://github.com/fog/fog-proxmox/issues/149)) ([9a303bc](https://github.com/fog/fog-proxmox/commit/9a303bc03a3d5049ded43d3ad1fa6ea79febd43e))
+
+
+### Miscellaneous Chores
+
+* allow major releases before 1.0 ([#156](https://github.com/fog/fog-proxmox/issues/156)) ([0752d55](https://github.com/fog/fog-proxmox/commit/0752d55fcfa0628c452c3bc7d7a137e341c8da4a))
+
 ## [0.16.2](https://github.com/fog/fog-proxmox/compare/v0.16.1...v0.16.2) (2026-08-12)
 
 

data/lib/fog/proxmox/compute/models/multipart_body.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+# This file is part of Fog::Proxmox.
+
+# Fog::Proxmox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# Fog::Proxmox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Fog::Proxmox. If not, see <http://www.gnu.org/licenses/>.
+
+module Fog
+  module Proxmox
+    # An IO-like multipart body that streams a file between a prefix and suffix.
+    class MultipartBody
+      attr_reader :size
+
+      def initialize(prefix, file, suffix)
+        @prefix = prefix
+        @file = file
+        @suffix = suffix
+        @size = prefix.bytesize + file_size + suffix.bytesize
+        rewind
+      end
+
+      def read(length = nil, outbuf = nil)
+        length = @size - @position if length.nil?
+        raise ArgumentError, 'negative length' if length.negative?
+
+        result = ::String.new(encoding: Encoding::BINARY)
+        read_into(result, length)
+        result = nil if result.empty? && length.positive? && @part > 2
+
+        return result unless outbuf
+
+        outbuf.replace(result || '')
+        result && outbuf
+      end
+
+      def rewind
+        @file.rewind
+        @part = 0
+        @offset = 0
+        @position = 0
+        0
+      end
+
+      def binmode
+        @file.binmode if @file.respond_to?(:binmode)
+        self
+      end
+
+      private
+
+      def file_size
+        return @file.size if @file.respond_to?(:size)
+        return @file.stat.size if @file.respond_to?(:stat)
+
+        raise ArgumentError, 'Upload file size cannot be determined'
+      end
+
+      def read_into(result, length)
+        while result.bytesize < length && @part <= 2
+          remaining = length - result.bytesize
+          chunk = @part == 1 ? @file.read(remaining) : read_string_part(remaining)
+
+          if chunk.nil? || chunk.empty?
+            @part += 1
+            @offset = 0
+          else
+            result << chunk
+            @position += chunk.bytesize
+          end
+        end
+      end
+
+      def read_string_part(length)
+        string = @part.zero? ? @prefix : @suffix
+        chunk = string.byteslice(@offset, length)
+        @offset += chunk.bytesize if chunk
+        chunk
+      end
+    end
+  end
+end

data/lib/fog/proxmox/compute/models/multipart_iso_upload.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+# This file is part of Fog::Proxmox.
+
+# Fog::Proxmox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# Fog::Proxmox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Fog::Proxmox. If not, see <http://www.gnu.org/licenses/>.
+
+require 'securerandom'
+require 'excon'
+require 'fog/proxmox/compute/models/multipart_body'
+
+module Fog
+  module Proxmox
+    # Prepares a streamed multipart ISO upload and its content type.
+    class MultipartIsoUpload
+      attr_reader :body, :content_type
+
+      def initialize(body_params)
+        filename = body_params.fetch(:filename)
+        raise ArgumentError, "Invalid ISO filename: #{filename}" unless filename.match?(/\A[a-zA-Z0-9][a-zA-Z0-9._-]*\.iso\z/i)
+
+        file = body_params.fetch(:file)
+
+        boundary = '-' * 30 + SecureRandom.hex(15)
+        prefix = build_multipart_content(boundary, 'content', 'iso')
+        prefix << build_multipart_header(boundary, 'filename', filename: filename)
+        @body = MultipartBody.new(prefix, file, build_multipart_closing(boundary))
+
+        @content_type = "multipart/form-data; boundary=#{boundary}"
+      end
+
+      private
+
+      def build_multipart_header(boundary, name, filename: nil)
+        newline = Excon::CR_NL
+        header = ::String.new(encoding: Encoding::BINARY)
+        header << "--#{boundary}#{newline}"
+        header << %(Content-Disposition: form-data; name="#{name}")
+        header << %(; filename="#{filename}") if filename
+        header << newline
+        header << "Content-Type: application/octet-stream#{newline}" if filename
+        header << newline
+      end
+
+      def build_multipart_content(boundary, name, value)
+        build_multipart_header(boundary, name) << value << Excon::CR_NL
+      end
+
+      def build_multipart_closing(boundary)
+        "#{Excon::CR_NL}--#{boundary}--#{Excon::CR_NL}".b
+      end
+    end
+  end
+end

data/lib/fog/proxmox/compute/models/storage.rb

@@ -26,6 +26,8 @@
 
 # frozen_string_literal: true
 
+require 'fog/proxmox/storage/models/iso_upload'
+
 module Fog
   module Proxmox
     class Compute
@@ -53,6 +55,10 @@ module Fog
           super(new_attributes)
         end
 
+        def upload_iso(path)
+          Fog::Proxmox::Storage::IsoUpload.new(service: service, node_id: node_id, storage_id: identity, path: path).upload
+        end
+
         private
 
         def initialize_volumes

data/lib/fog/proxmox/core.rb

@@ -93,8 +93,8 @@ module Fog
         begin
           authenticate! if expired?
           request_options = params.merge(path: "#{@path}/#{params[:path]}",
-                                         headers: @auth_token.headers(
-                                           params[:method], params.respond_to?(:headers) ? params[:headers] : {}, {}
+                                         headers: (params[:headers] || {}).merge(
+                                           @auth_token.headers(params[:method], {}, {})
                                          ))
           response = @connection.request(request_options)
         rescue Excon::Errors::Unauthorized => e
@@ -102,6 +102,7 @@ module Fog
           if !%w[Bad username or password, invalid token
                  value!].include?(e.response.body) && @proxmox_can_reauthenticate && !retried
             authenticate!
+            params[:body].rewind if params[:body].respond_to?(:rewind)
             retried = true
             retry
           # bad credentials or token renewal not possible

data/lib/fog/proxmox/storage/models/iso_upload.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Fog
+  module Proxmox
+    class Storage
+      # Uploads a local ISO and waits for the Proxmox task to finish.
+      class IsoUpload < Fog::Model
+        attribute :node_id
+        attribute :storage_id
+        attribute :path
+
+        def upload
+          requires :node_id, :storage_id, :path
+
+          filename = File.basename(path)
+          size = File.size(path)
+          Fog::Logger.debug("Starting Proxmox ISO upload filename=#{filename} size=#{size} bytes node=#{node_id} storage=#{storage_id}")
+          response = File.open(path, 'rb') do |file|
+            Fog::Proxmox::Storage.new(service.config).upload_iso(
+              { node: node_id, storage: storage_id },
+              { filename: filename, file: file }
+            )
+          end
+          Fog::Logger.debug("Upload response: #{response.inspect}")
+          raise Fog::Errors::Error, "Unexpected upload response: #{response.inspect}" unless response.to_s.start_with?('UPID:')
+
+          service.nodes.get(node_id).tasks.wait_for(response)
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/proxmox/storage/requests/upload_iso.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# This file is part of Fog::Proxmox.
+
+# Fog::Proxmox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# Fog::Proxmox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Fog::Proxmox. If not, see <http://www.gnu.org/licenses/>.
+
+require 'fog/proxmox/compute/models/multipart_iso_upload'
+
+module Fog
+  module Proxmox
+    class Storage
+      # class Real upload_iso request
+      class Real
+        def upload_iso(path_params, body_params)
+          node = path_params[:node]
+          storage = path_params[:storage]
+          upload = MultipartIsoUpload.new(body_params)
+
+          request(
+            expects: [200],
+            method: 'POST',
+            path: "nodes/#{node}/storage/#{storage}/upload",
+            body: upload.body,
+            headers: { 'Content-Type' => upload.content_type }
+          )
+        end
+      end
+
+      # class Mock upload_iso request
+      class Mock
+        def upload_iso(_path_params, _body_params); end
+      end
+    end
+  end
+end

data/lib/fog/proxmox/storage.rb

@@ -18,12 +18,70 @@
 
 # frozen_string_literal: true
 
+require 'fog/proxmox/core'
+
 module Fog
   module Proxmox
-    # Procmox storage service
+    # Proxmox storage service
     class Storage < Fog::Service
-      # Models
-      model_path 'fog/proxmox/storage'
+      requires :proxmox_url, :proxmox_auth_method
+      recognizes :proxmox_token, :proxmox_tokenid, :proxmox_userid, :persistent, :proxmox_username, :proxmox_password
+
+      model_path 'fog/proxmox/storage/models'
+      model :iso_upload
+
+      request_path 'fog/proxmox/storage/requests'
+      request :upload_iso
+
+      # Mock class
+      class Mock
+        attr_reader :config
+
+        def initialize(options = {})
+          @proxmox_uri = URI.parse(options[:proxmox_url])
+          @proxmox_auth_method = options[:proxmox_auth_method]
+          @proxmox_tokenid = options[:proxmox_tokenid]
+          @proxmox_userid = options[:proxmox_userid]
+          @proxmox_username = options[:proxmox_username]
+          @proxmox_password = options[:proxmox_password]
+          @proxmox_token = options[:proxmox_token]
+          @proxmox_path = @proxmox_uri.path
+          @config = options
+        end
+      end
+
+      # Real class
+      class Real
+        include Fog::Proxmox::Core
+
+        def initialize(options = {})
+          if options.respond_to?(:config_service?) && options.config_service?
+            configure(options)
+          else
+            super
+          end
+        end
+
+        def self.not_found_class
+          Fog::Proxmox::Storage::NotFound
+        end
+
+        def config
+          self
+        end
+
+        def config_service?
+          true
+        end
+
+        private
+
+        def configure(source)
+          source.instance_variables.each do |v|
+            instance_variable_set(v, source.instance_variable_get(v))
+          end
+        end
+      end
     end
   end
 end

data/lib/fog/proxmox/version.rb

@@ -19,6 +19,6 @@
 
 module Fog
   module Proxmox
-    VERSION = '0.16.2'
+    VERSION = '1.0.0'
   end
 end

data/spec/fog/proxmox/compute/models/multipart_body_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# This file is part of Fog::Proxmox.
+
+# Fog::Proxmox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# Fog::Proxmox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Fog::Proxmox. If not, see <http://www.gnu.org/licenses/>.
+
+require 'spec_helper'
+require 'stringio'
+require 'fog/proxmox/compute/models/multipart_body'
+
+multipart_body_class = Fog::Proxmox::MultipartBody
+
+# Match the implementation's compute/models location despite its shared namespace.
+describe Fog::Proxmox::MultipartBody do # rubocop:disable RSpec/SpecFilePathFormat
+  it 'streams and rewinds all multipart sections' do
+    body = multipart_body_class.new('prefix', StringIO.new('file'), 'suffix')
+
+    _(body.size).must_equal 16
+    _(body.read(8)).must_equal 'prefixfi'
+    _(body.read).must_equal 'lesuffix'
+    _(body.read(1)).must_be_nil
+
+    body.rewind
+    _(body.read).must_equal 'prefixfilesuffix'
+  end
+
+  it 'clears the output buffer and returns nil at EOF' do
+    body = multipart_body_class.new('prefix', StringIO.new('file'), 'suffix')
+    body.read
+    outbuf = String.new('existing')
+
+    _(body.read(1, outbuf)).must_be_nil
+    _(outbuf).must_be_empty
+  end
+end

data/spec/fog/proxmox/storage/real_upload_iso_spec.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+# This file is part of Fog::Proxmox.
+
+# Fog::Proxmox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# Fog::Proxmox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Fog::Proxmox. If not, see <http://www.gnu.org/licenses/>.
+
+require 'spec_helper'
+require 'stringio'
+require 'fog/proxmox/storage/requests/upload_iso'
+
+real_storage_class = Fog::Proxmox::Storage::Real
+
+describe Fog::Proxmox::Storage::Real do
+  it 'loads the upload request and reuses an authenticated compute connection' do
+    auth_request = WebMock.stub_request(:get, 'https://pve.example.test/api2/json/access/users/root@pam/token/test')
+                          .to_return(body: '{"data":{"expire":0}}')
+    compute = Fog::Proxmox::Compute.new(
+      proxmox_url: 'https://pve.example.test/api2/json',
+      proxmox_auth_method: 'user_token',
+      proxmox_userid: 'root@pam',
+      proxmox_tokenid: 'test',
+      proxmox_token: 'test-token'
+    )
+    storage = Fog::Proxmox::Storage.new(compute.config)
+
+    _(storage).must_be_kind_of real_storage_class
+    _(storage).must_respond_to :upload_iso
+    _(storage.instance_variable_get(:@connection)).must_be_same_as compute.instance_variable_get(:@connection)
+    _(storage.instance_variable_get(:@auth_token)).must_be_same_as compute.instance_variable_get(:@auth_token)
+    _(compute).wont_respond_to :upload_iso
+  ensure
+    WebMock.remove_request_stub(auth_request)
+  end
+
+  describe '#upload_iso' do
+    it 'streams a multipart ISO upload request' do
+      service = real_storage_class.allocate
+      iso_data = "cloud-init\x00\xFF".b
+      source = StringIO.new(iso_data)
+      read_lengths = []
+      file = Object.new
+      file.define_singleton_method(:size) { source.size }
+      file.define_singleton_method(:rewind) { source.rewind }
+      file.define_singleton_method(:read) do |length|
+        read_lengths << length
+        source.read(length)
+      end
+      source.read
+      request_options = nil
+
+      service.stub(:request, lambda { |options|
+        request_options = options
+        'uploaded'
+      }) do
+        result = service.upload_iso(
+          { node: 'pve', storage: 'local' },
+          { filename: 'vm-cloudinit.iso', file: file }
+        )
+
+        _(result).must_equal 'uploaded'
+      end
+
+      _(request_options[:expects]).must_equal [200]
+      _(request_options[:method]).must_equal 'POST'
+      _(request_options[:path]).must_equal 'nodes/pve/storage/local/upload'
+      _(request_options[:headers]['Content-Type']).must_match(%r{\Amultipart/form-data; boundary=})
+      body = request_options[:body]
+      chunks = []
+      while (chunk = body.read(4))
+        chunks << chunk
+      end
+      encoded_body = chunks.join
+
+      _(body).must_be_kind_of Fog::Proxmox::MultipartBody
+      _(body.size).must_equal encoded_body.bytesize
+      _(encoded_body).must_include %(name="content"#{Excon::CR_NL}#{Excon::CR_NL}iso)
+      _(encoded_body).must_include %(name="filename"; filename="vm-cloudinit.iso")
+      _(encoded_body).must_include 'Content-Type: application/octet-stream'
+      _(encoded_body).must_include iso_data
+      _(read_lengths).wont_be_empty
+      _(read_lengths.all? { |length| length <= 4 }).must_equal true
+
+      body.rewind
+      _(body.read(body.size)).must_equal encoded_body
+    end
+
+    it 'rejects an unsafe filename' do
+      service = real_storage_class.allocate
+
+      error = _(proc do
+        service.upload_iso(
+          { node: 'pve', storage: 'local' },
+          { filename: "bad\r\nname.iso", file: StringIO.new('iso') }
+        )
+      end).must_raise ArgumentError
+
+      _(error.message).must_match(/Invalid ISO filename/)
+    end
+
+    it 'accepts an uppercase ISO extension' do
+      service = real_storage_class.allocate
+      service.stub(:request, 'uploaded') do
+        result = service.upload_iso(
+          { node: 'pve', storage: 'local' },
+          { filename: 'installer.ISO', file: StringIO.new('iso') }
+        )
+
+        _(result).must_equal 'uploaded'
+      end
+    end
+  end
+
+  describe '#request' do
+    it 'merges caller headers without overriding authentication headers' do
+      service = real_storage_class.allocate
+      auth_token = Object.new
+      auth_token.define_singleton_method(:headers) do |_method, _params, _additional_headers|
+        { 'Authorization' => 'PVEAPIToken=test' }
+      end
+
+      request_options = nil
+      response = Struct.new(:body).new('{"data":"uploaded"}')
+      connection = Object.new
+      connection.define_singleton_method(:request) do |options|
+        request_options = options
+        response
+      end
+
+      service.instance_variable_set(:@auth_token, auth_token)
+      service.instance_variable_set(:@connection, connection)
+      service.instance_variable_set(:@expires, nil)
+      service.instance_variable_set(:@path, '/api2/json')
+
+      result = service.send(
+        :request,
+        method: 'POST',
+        path: 'nodes/pve/storage/local/upload',
+        headers: {
+          'Authorization' => 'caller-supplied-token',
+          'Content-Type' => 'multipart/form-data; boundary=test'
+        }
+      )
+
+      _(result).must_equal 'uploaded'
+      _(request_options[:headers]).must_equal(
+        'Authorization' => 'PVEAPIToken=test',
+        'Content-Type' => 'multipart/form-data; boundary=test'
+      )
+    end
+  end
+end

data/spec/fog/proxmox/storage/storage_upload_iso_spec.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'tempfile'
+require 'fog/proxmox/attributes'
+require 'fog/proxmox/compute/models/volumes'
+require 'fog/proxmox/compute/models/storage'
+
+storage_class = Fog::Proxmox::Compute::Storage
+
+describe Fog::Proxmox::Compute::Storage do # rubocop:disable RSpec/SpecFilePathFormat
+  let(:service) { Minitest::Mock.new }
+  let(:upload_service) { Minitest::Mock.new }
+  let(:storage) { storage_class.new(service: service, node_id: 'pve', storage: 'local') }
+  let(:iso) { Tempfile.new(['cloudinit', '.iso']) }
+
+  attr_accessor :uploaded_file
+
+  before do
+    service.expect(:nil?, false)
+    storage
+    iso.binmode
+    iso.write("cloud-init\x00\xFF".b)
+    iso.flush
+  end
+
+  after do
+    iso.close!
+  end
+
+  def expect_upload(response, error: nil)
+    service.expect(:nil?, false)
+    service.expect(:config, :compute_config)
+    upload_service.expect(:upload_iso, response) do |path, body|
+      _(path).must_equal(node: 'pve', storage: 'local')
+      _(body[:filename]).must_equal File.basename(iso.path)
+      self.uploaded_file = body[:file]
+      _(uploaded_file.read).must_equal "cloud-init\x00\xFF".b
+      raise error if error
+
+      true
+    end
+  end
+
+  def upload_iso
+    factory = lambda do |config|
+      _(config).must_equal :compute_config
+      upload_service
+    end
+    Fog::Proxmox::Storage.stub(:new, factory) do
+      storage.upload_iso(iso.path)
+    end
+  ensure
+    upload_service.verify
+  end
+
+  def expect_wait(error: nil)
+    tasks = Object.new
+    test = self
+    tasks.define_singleton_method(:wait_for) do |upid|
+      test.assert_equal 'UPID:upload', upid
+      test.assert_predicate test.uploaded_file, :closed?
+      raise error if error
+
+      true
+    end
+    nodes = Minitest::Mock.new
+    nodes.expect(:get, Struct.new(:tasks).new(tasks), ['pve'])
+    service.expect(:nodes, nodes)
+    nodes
+  end
+
+  it 'uploads to its node and storage, closes the file, and waits before returning the UPID' do
+    expect_upload('UPID:upload')
+    nodes = expect_wait
+
+    _(upload_iso).must_equal 'UPID:upload'
+    service.verify
+    nodes.verify
+  end
+
+  it 'rejects an invalid response without polling tasks' do
+    expect_upload(nil)
+
+    error = _(proc { upload_iso }).must_raise Fog::Errors::Error
+    _(error.message).must_equal 'Unexpected upload response: nil'
+    _(uploaded_file.closed?).must_equal true
+    service.verify
+  end
+
+  it 'closes the file when the upload request fails' do
+    expect_upload(nil, error: Fog::Errors::Error.new('Upload failed'))
+
+    error = _(proc { upload_iso }).must_raise Fog::Errors::Error
+    _(error.message).must_equal 'Upload failed'
+    _(uploaded_file.closed?).must_equal true
+  end
+
+  it 'propagates task failures' do
+    expect_upload('UPID:upload')
+    nodes = expect_wait(error: Fog::Errors::Error.new('Task failed'))
+
+    error = _(proc { upload_iso }).must_raise Fog::Errors::Error
+    _(error.message).must_equal 'Task failed'
+    service.verify
+    nodes.verify
+  end
+end

data/spec/proxmox_vcr.rb

@@ -45,9 +45,9 @@ class ProxmoxVCR
 
     if use_recorded
       Fog.interval = 0
-      @url  = 'https://192.168.56.101:8006/api2/json'
+      @url = 'https://192.168.56.101:8006/api2/json'
     else
-      @url  = ENV['PROXMOX_URL']
+      @url = ENV['PROXMOX_URL']
     end
 
     VCR.configure do |config|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fog-proxmox
 version: !ruby/object:Gem::Version
-  version: 0.16.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Tristan Robert
@@ -260,6 +260,8 @@ files:
 - lib/fog/proxmox/compute/models/efidisk.rb
 - lib/fog/proxmox/compute/models/interface.rb
 - lib/fog/proxmox/compute/models/interfaces.rb
+- lib/fog/proxmox/compute/models/multipart_body.rb
+- lib/fog/proxmox/compute/models/multipart_iso_upload.rb
 - lib/fog/proxmox/compute/models/node.rb
 - lib/fog/proxmox/compute/models/nodes.rb
 - lib/fog/proxmox/compute/models/server.rb
@@ -388,6 +390,8 @@ files:
 - lib/fog/proxmox/network/requests/power_node.rb
 - lib/fog/proxmox/network/requests/update_network.rb
 - lib/fog/proxmox/storage.rb
+- lib/fog/proxmox/storage/models/iso_upload.rb
+- lib/fog/proxmox/storage/requests/upload_iso.rb
 - lib/fog/proxmox/string.rb
 - lib/fog/proxmox/variables.rb
 - lib/fog/proxmox/version.rb
@@ -414,6 +418,9 @@ files:
 - spec/fixtures/proxmox/network/common_auth.yml
 - spec/fixtures/proxmox/network/networks.yml
 - spec/fixtures/proxmox/pve.home
+- spec/fog/proxmox/compute/models/multipart_body_spec.rb
+- spec/fog/proxmox/storage/real_upload_iso_spec.rb
+- spec/fog/proxmox/storage/storage_upload_iso_spec.rb
 - spec/hash_spec.rb
 - spec/helpers/controller_helper_spec.rb
 - spec/helpers/cpu_helper_spec.rb