fog-proxmox 0.4.0

data/lib/fog/network/proxmox/requests/power_node.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+# Copyright 2018 Tristan Robert
+
+# 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/>.
+
+# frozen_string_literal: true
+
+require 'fog/proxmox/json'
+
+module Fog
+  module Network
+    class Proxmox
+      # class Real power_node request
+      class Real
+        def power_node(path_params, body_params)
+          node = path_params[:node]
+          response = request(
+            expects: [200],
+            method: 'POST',
+            path: "nodes/#{node}/status",
+            body: URI.encode_www_form(body_params)
+          )
+          Fog::Proxmox::Json.get_data(response)
+        end
+      end
+
+      # class Mock power_node request
+      class Mock
+        def power_node; end
+      end
+    end
+  end
+end

data/lib/fog/network/proxmox/requests/update_network.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# Copyright 2018 Tristan Robert
+
+# 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/json'
+
+module Fog
+  module Network
+    class Proxmox
+      # class Real update_network request
+      class Real
+        def update_network(path_params, body_params)
+          node = path_params[:node]
+          type = body_params[:type]
+          iface = path_params[:iface]
+          response = request(
+            expects: [200],
+            method: 'PUT',
+            path: "nodes/#{node}/network/#{iface}",
+            body: URI.encode_www_form(body_params)
+          )
+          Fog::Proxmox::Json.get_data(response)
+        end
+      end
+
+      # class Mock update_network request
+      class Mock
+      end
+    end
+  end
+end

data/lib/fog/proxmox.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+# Copyright 2018 Tristan Robert
+
+# 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/>.
+
+# frozen_string_literal: true
+
+require 'fog/proxmox/version'
+require 'fog/proxmox/core'
+require 'fog/proxmox/json'
+require 'fog/core'
+require 'fog/json'
+
+module Fog
+  # Identity module
+  module Identity
+    autoload :Proxmox, File.expand_path('identity/proxmox', __dir__)
+  end
+  # Compute module
+  module Compute
+    autoload :Proxmox, File.expand_path('compute/proxmox', __dir__)
+  end
+  # Storage module
+  module Storage
+    autoload :Proxmox, File.expand_path('storage/proxmox', __dir__)
+  end
+  # Network module
+  module Network
+    autoload :Proxmox, File.expand_path('network/proxmox', __dir__)
+  end
+
+  # Proxmox module
+  module Proxmox
+    extend Fog::Provider
+    service(:identity, 'Identity')
+    service(:compute, 'Compute')
+    service(:storage, 'Storage')
+    service(:network, 'Network')
+
+    @cache = {}
+
+    # Default lifetime ticket is 2 hours
+    @ticket_lifetime = 2 * 60 * 60
+
+    class << self
+      attr_accessor :cache
+      attr_reader :version
+    end
+
+    def self.clear_cache
+      Fog::Proxmox.cache = {}
+    end
+
+    def self.authenticate(options, connection_options = {})
+      get_tokens(options, connection_options)
+      @cache
+    end
+
+    def self.authenticated?
+      !@cache.empty?
+    end
+
+    def self.extract_password(options)
+      ticket = options[:pve_ticket]
+      options[:pve_password] = ticket unless ticket
+    end
+
+    def self.get_tokens(options, connection_options = {})
+      username          = options[:pve_username].to_s
+      password          = options[:pve_password].to_s
+      url               = options[:pve_url]
+      extract_password(options)
+      uri = URI.parse(url)
+      @api_path = uri.path
+      connection_options = connection_options.merge(path_prefix: @api_path)
+      retrieve_tokens(uri, connection_options, username, password) unless authenticated?
+    end
+
+    def self.retrieve_tokens(uri, connection_options, username, password)
+      request = {
+        expects: [200, 204],
+        headers: { 'Accept' => 'application/json' },
+        body: "username=#{username}&password=#{password}",
+        method: 'POST',
+        path: 'access/ticket'
+      }
+
+      connection = Fog::Core::Connection.new(
+        uri.to_s,
+        false,
+        connection_options
+      )
+
+      response  = connection.request(request)
+      data      = Json.get_data(response)
+      ticket    = data['ticket']
+      username  = data['username']
+      csrftoken = data['CSRFPreventionToken']
+
+      now = Time.now
+      deadline = Time.at(now.to_i + @ticket_lifetime)
+      save_token(username, ticket, csrftoken, deadline)
+    end
+
+    def self.save_token(username, ticket, csrftoken, deadline)
+      @cache = {
+        username: username,
+        ticket: ticket,
+        csrftoken: csrftoken,
+        deadline: deadline
+      }
+      Fog::Proxmox.cache = @cache
+    end
+  end
+end

data/lib/fog/proxmox/core.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+# Copyright 2018 Tristan Robert
+
+# 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/json'
+require 'fog/proxmox/variables'
+
+module Fog
+  module Proxmox
+    # Core module
+    module Core
+      attr_accessor :pve_ticket
+      attr_reader :pve_csrftoken
+      attr_reader :pve_username
+      attr_reader :deadline
+      attr_reader :principal
+
+      # fallback
+      def self.not_found_class
+        Fog::Compute::Proxmox::NotFound
+      end
+
+      def initialize_identity(options)
+        @principal = nil
+        @pve_must_reauthenticate = true
+        @pve_ticket = nil
+        Fog::Proxmox::Variables.to_variables(self, options, 'pve')
+        @pve_uri = URI.parse(@pve_url)
+        @pve_must_reauthenticate = true unless @pve_ticket
+        missing_credentials = []
+        missing_credentials << :pve_username unless @pve_username
+
+        unless @pve_ticket
+          missing_credentials << :pve_password unless @pve_password
+        end
+
+        raise ArgumentError, "Missing required arguments: #{missing_credentials.join(', ')}" unless missing_credentials.empty?
+      end
+
+      def credentials
+        options = {
+          provider: 'proxmox',
+          pve_url: @pve_uri.to_s,
+          pve_ticket: @pve_ticket,
+          pve_csrftoken: @pve_csrftoken,
+          pve_username: @pve_username
+        }
+        pve_options.merge options
+      end
+
+      def reload
+        @connection.reset
+      end
+
+      private
+
+      def request(params)
+        retried = false
+        begin
+          response = @connection.request(params.merge(
+                                           headers: headers(params[:method], params[:headers])
+          ))
+        rescue Excon::Errors::Unauthorized => error
+          # token expiration and token renewal possible
+          if error.response.body != 'Bad username or password' && @pve_can_reauthenticate && !retried
+            authenticate
+            retried = true
+            retry
+          # bad credentials or token renewal not possible
+          else
+            raise error
+          end
+        rescue Excon::Errors::HTTPStatusError => error
+          raise case error
+                when Excon::Errors::NotFound
+                  self.class.not_found_class.slurp(error)
+                else
+                  error
+                end
+        end
+        response
+      end
+
+      def headers(method, additional_headers)
+        additional_headers ||= {}
+        headers_hash = { 'Accept' => 'application/json' }
+        # CSRF token is required to PUT, POST and DELETE http requests
+        if %w[PUT POST DELETE].include? method
+          headers_hash.store('CSRFPreventionToken', @pve_csrftoken)
+        end
+        # ticket must be present in cookie
+        headers_hash.store('Cookie', "PVEAuthCookie=#{@pve_ticket}") if @pve_ticket
+        headers_hash.merge additional_headers
+        headers_hash
+      end
+
+      def pve_options
+        Fog::Proxmox::Variables.to_hash(self, 'pve')
+      end
+
+      def authenticate
+        unless @principal
+          options = pve_options
+          options[:pve_ticket] = @pve_must_reauthenticate ? nil : @pve_ticket
+          credentials = Fog::Proxmox.authenticate(options, @connection_options)
+          @principal = credentials
+          @pve_username = credentials[:username]
+          @pve_ticket = credentials[:ticket]
+          @pve_deadline = credentials[:deadline]
+          @pve_csrftoken = credentials[:csrftoken]
+          @pve_must_reauthenticate = false
+        end
+
+        @host       = @pve_uri.host
+        @api_path   = @pve_uri.path
+        @api_path.sub!(%r{/$}, '')
+        @port       = @pve_uri.port
+        @scheme     = @pve_uri.scheme
+
+        true
+      end
+    end
+  end
+end

data/lib/fog/proxmox/errors.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+# Copyright 2018 Tristan Robert
+
+# 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
+    module Errors
+      # class ServiceError
+      class ServiceError < Fog::Errors::Error
+        attr_reader :response_data
+
+        def self.slurp(error)
+          if error.response.body.empty?
+            data = nil
+            message = nil
+          else
+            data = Fog::JSON.decode(error.response.body)
+            message = data['message']
+            data1 = data.values.first
+            message = data1['message'] if message.nil? && !data1.nil?
+          end
+
+          new_error = super(error, message)
+          new_error.instance_variable_set(:@response_data, data)
+          new_error
+        end
+      end
+
+      # class ServiceUnavailable error
+      class ServiceUnavailable < ServiceError; end
+
+      # class BadRequest error
+      class BadRequest < ServiceError
+        attr_reader :validation_errors
+
+        def self.slurp(error)
+          new_error = super(error)
+          unless new_error.response_data.nil? || new_error.response_data['badRequest'].nil?
+            new_error.instance_variable_set(:@validation_errors, new_error.response_data['badRequest']['validationErrors'])
+          end
+          new_error
+        end
+      end
+
+      # class InterfaceNotImplemented error
+      class InterfaceNotImplemented < Fog::Errors::Error; end
+    end
+  end
+end

data/lib/fog/proxmox/hash.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# Copyright 2018 Tristan Robert
+
+# 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
+    # module Hash mixins
+    module Hash
+      def self.stringify(hash)
+        string = ''
+        hash.each do |key, value|
+          string += "#{key}=#{value},"
+        end
+        string.slice(0, string.length - 1)
+      end
+    end
+  end
+end