azure_file_shares 0.1.5

data/lib/azure_file_shares/configuration.rb

@@ -0,0 +1,58 @@
+module AzureFileShares
+  # Configuration options for the AzureFileShares client
+  class Configuration
+    # API endpoints
+    DEFAULT_API_VERSION = "2024-01-01"
+    DEFAULT_BASE_URL = "https://management.azure.com"
+
+    # Configuration attributes
+    attr_accessor :tenant_id,
+                  :client_id,
+                  :client_secret,
+                  :subscription_id,
+                  :resource_group_name,
+                  :storage_account_name,
+                  :storage_account_key,
+                  # :sas_token,
+                  :api_version,
+                  :base_url,
+                  :request_timeout,
+                  :logger
+
+    # Initialize a new Configuration object with default values
+    def initialize
+      @api_version = DEFAULT_API_VERSION
+      @base_url = DEFAULT_BASE_URL
+      @request_timeout = 60 # seconds
+      @logger = nil
+    end
+
+    # Validates the configuration
+    # @return [Boolean] true if valid
+    # @raise [AzureFileShares::Errors::ConfigurationError] if configuration is invalid
+    def validate!
+      # For file operations with SAS token
+      # if storage_account_name && sas_token
+      #   return true
+      # end
+
+      # For file operations only
+      if storage_account_name && storage_account_key
+        return true
+      end
+
+      # For ARM operations (share management)
+      required_fields = %i[tenant_id client_id client_secret subscription_id]
+      missing_fields = required_fields.select { |field| send(field).nil? || send(field).to_s.strip.empty? }
+
+      unless missing_fields.empty?
+        missing = missing_fields.map(&:to_s).join(", ")
+        raise AzureFileShares::Errors::ConfigurationError,
+          "Missing required configuration: #{missing}. " +
+          "Note: For file operations only, just storage_account_name with either storage_account_key or sas_token is required."
+      end
+
+      true
+    end
+  end
+end

data/lib/azure_file_shares/errors/api_error.rb

@@ -0,0 +1,18 @@
+module AzureFileShares
+  module Errors
+    # Base error class for API-related errors
+    class ApiError < StandardError
+      attr_reader :status, :response
+
+      # Initialize a new API error
+      # @param [String] message Error message
+      # @param [Integer] status HTTP status code
+      # @param [Hash] response Full response object
+      def initialize(message = nil, status = nil, response = nil)
+        @status = status
+        @response = response
+        super(message)
+      end
+    end
+  end
+end

data/lib/azure_file_shares/errors/configuration_error.rb

@@ -0,0 +1,6 @@
+module AzureFileShares
+  module Errors
+    # Configuration error class
+    class ConfigurationError < StandardError; end
+  end
+end

data/lib/azure_file_shares/operations/base_operation.rb

@@ -0,0 +1,90 @@
+module AzureFileShares
+  module Operations
+    # Base class for all API operations
+    class BaseOperation
+      attr_reader :client
+
+      # Initialize a new operation with a client
+      # @param [AzureFileShares::Client] client The API client
+      def initialize(client)
+        @client = client
+      end
+
+      private
+
+      # Build the base path for storage account operations
+      # @return [String] Base path
+      def base_path
+        "/subscriptions/#{client.subscription_id}" \
+          "/resourceGroups/#{client.resource_group_name}" \
+          "/providers/Microsoft.Storage" \
+          "/storageAccounts/#{client.storage_account_name}"
+      end
+
+      # Build the full request URL
+      # @param [String] path The API endpoint path
+      # @return [String] Full URL
+      def build_url(path, params = {})
+        url = URI.join(client.base_url, path).to_s
+        url += "?api-version=#{client.api_version}"
+
+        params.each do |key, value|
+          url += "&#{key}=#{URI.encode_www_form_component(value.to_s)}"
+        end
+
+        url
+      end
+
+      # Send a request to the API
+      # @param [Symbol] method HTTP method (:get, :post, :put, :delete, etc.)
+      # @param [String] path API endpoint path
+      # @param [Hash] params Query parameters to include in the URL
+      # @param [Hash] body Request body (for POST, PUT, PATCH)
+      # @return [Hash] Parsed JSON response
+      # @raise [AzureFileShares::Errors::ApiError] If the request fails
+      def request(method, path, params = {}, body = nil)
+        url = build_url(path, params)
+
+        response = client.connection.public_send(method) do |req|
+          req.url url
+          req.headers["Authorization"] = "Bearer #{client.access_token}"
+          req.headers["Content-Type"] = "application/json"
+          req.body = JSON.generate(body) if body
+        end
+
+        handle_response(response)
+      end
+
+      # Handle the API response, raising errors when necessary
+      # @param [Faraday::Response] response The HTTP response
+      # @return [Hash, Array] Parsed JSON response
+      # @raise [AzureFileShares::Errors::ApiError] If the request fails
+      def handle_response(response)
+        puts "Response: #{response.inspect}"
+        case response.status
+        when 200..299
+          return {} if response.body.nil? || response.body.empty?
+
+          begin
+            JSON.parse(response.body)
+          rescue JSON::ParserError
+            response.body
+          end
+        else
+          error_message = begin
+            error_data = JSON.parse(response.body)
+            error_data.dig("error", "message") || response.reason_phrase
+          rescue JSON::ParserError
+            response.reason_phrase || "Unknown error"
+          end
+
+          raise AzureFileShares::Errors::ApiError.new(
+            "API Error (#{response.status}): #{error_message}",
+            response.status,
+            response.body
+          )
+        end
+      end
+    end
+  end
+end