azure-blob 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5ff6c7e8f9d7ec11e85bcb1ea543b9344a9db958fea0d9451221c5be161e0d8b
+  data.tar.gz: fc1a13d7c8f39303c5985de80b7790a378f6a1901b22e4f8cce1eb85789aaeb4
+SHA512:
+  metadata.gz: eabce34cd075764436fc473b550451fadf2f764a731464345ba2542a7e1ca5f5e5d44286b94b19d11eda554fde4e4a17faaf40eb8ad3ed2e9d8bab798ba8e2bb
+  data.tar.gz: 793a8c163e2b7d489bfd8d4a643ba6c466d043652e5cce3f6ee2798142bfb36ce41e0881028712b57ab45eb357704af3c64d47e66c53d631ee949a50d22c310f

data/.envrc

@@ -0,0 +1,3 @@
+source_url "https://raw.githubusercontent.com/cachix/devenv/d1f7b48e35e6dee421cfd0f51481d17f77586997/direnvrc" "sha256-YBzqskFZxmNb3kYVoKD9ZixoPXJh1C9ZvTLGFRkauZ0="
+
+use devenv

data/.rubocop.yml

@@ -0,0 +1,25 @@
+AllCops:
+  TargetRubyVersion: 3.1
+
+# Omakase Ruby styling for Rails
+inherit_gem: { rubocop-rails-omakase: rubocop.yml }
+
+# Overwrite or add rules to create your own house style
+#
+# # Use `[a, [b, c]]` not `[ a, [ b, c ] ]`
+# Layout/SpaceInsideArrayLiteralBrackets:
+#   Enabled: false
+
+Style/TrailingCommaInArrayLiteral:
+  Enabled: true
+  EnforcedStyleForMultiline: consistent_comma
+
+Style/TrailingCommaInHashLiteral:
+  Enabled: true
+  EnforcedStyleForMultiline: consistent_comma
+
+
+Rails/AssertNot:
+  Enabled: false
+Rails/RefuteMethods:
+  Enabled: false

data/.standard.yml

@@ -0,0 +1,3 @@
+# For available configuration options, see:
+#   https://github.com/standardrb/standard
+ruby_version: 3.1

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2024-04-05
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Joé Dupuis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,7 @@
+# AzureBlob
+
+WIP This gem is built as a replacement of azure-storage-blob (deprecated) in Active Storage
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+task default: %i[test]

data/azure-blob.gemspec

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "lib/azure_blob/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "azure-blob"
+  spec.version = AzureBlob::VERSION
+  spec.authors = [ "Joé Dupuis" ]
+  spec.email = [ "joe@dupuis.io" ]
+
+  spec.summary = "Azure blob client"
+  spec.homepage = "https://github.com/JoeDupuis/azure-blob"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.1"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "https://github.com/JoeDupuis/azure-blob/blob/main/CHANGELOG.md"
+
+  spec.add_dependency "rexml"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .github appveyor Gemfile])
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = [ "lib" ]
+end

data/devenv.lock

@@ -0,0 +1,242 @@
+{
+  "nodes": {
+    "devenv": {
+      "locked": {
+        "dir": "src/modules",
+        "lastModified": 1715593316,
+        "narHash": "sha256-S7XatU9uV3q9bVBcg/ER0VMQcnPZprrVlN209ne7LDw=",
+        "owner": "cachix",
+        "repo": "devenv",
+        "rev": "725c90407ef53cc2a1b53701c6d2d0745cf2484f",
+        "type": "github"
+      },
+      "original": {
+        "dir": "src/modules",
+        "owner": "cachix",
+        "repo": "devenv",
+        "type": "github"
+      }
+    },
+    "flake-compat": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1696426674,
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "rev": "0f9255e01c2351cc7d116c072cb317785dd33b33",
+        "treeHash": "2addb7b71a20a25ea74feeaf5c2f6a6b30898ecb",
+        "type": "github"
+      },
+      "original": {
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "type": "github"
+      }
+    },
+    "flake-compat_2": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1696426674,
+        "narHash": "sha256-kvjfFW7WAETZlt09AgDn1MrtKzP7t90Vf7vypd3OL1U=",
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "rev": "0f9255e01c2351cc7d116c072cb317785dd33b33",
+        "type": "github"
+      },
+      "original": {
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "type": "github"
+      }
+    },
+    "flake-utils": {
+      "inputs": {
+        "systems": "systems"
+      },
+      "locked": {
+        "lastModified": 1710146030,
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "b1d9ab70662946ef0850d488da1c9019f3a9752a",
+        "treeHash": "bd263f021e345cb4a39d80c126ab650bebc3c10c",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "flake-utils_2": {
+      "inputs": {
+        "systems": "systems_2"
+      },
+      "locked": {
+        "lastModified": 1710146030,
+        "narHash": "sha256-SZ5L6eA7HJ/nmkzGG7/ISclqe6oZdOZTNoesiInkXPQ=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "b1d9ab70662946ef0850d488da1c9019f3a9752a",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "gitignore": {
+      "inputs": {
+        "nixpkgs": [
+          "pre-commit-hooks",
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1709087332,
+        "narHash": "sha256-HG2cCnktfHsKV0s4XW83gU3F57gaTljL9KNSuG6bnQs=",
+        "owner": "hercules-ci",
+        "repo": "gitignore.nix",
+        "rev": "637db329424fd7e46cf4185293b9cc8c88c95394",
+        "type": "github"
+      },
+      "original": {
+        "owner": "hercules-ci",
+        "repo": "gitignore.nix",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1715542476,
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "44072e24566c5bcc0b7aa9178a0104f4cfffab19",
+        "treeHash": "3f9021e4c33de6fe59b88ac8c3019fc49136dc2a",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-23.11",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs-ruby": {
+      "inputs": {
+        "flake-compat": "flake-compat",
+        "flake-utils": "flake-utils",
+        "nixpkgs": "nixpkgs_2"
+      },
+      "locked": {
+        "lastModified": 1713939467,
+        "owner": "bobvanderlinden",
+        "repo": "nixpkgs-ruby",
+        "rev": "c1ba161adf31119cfdbb24489766a7bcd4dbe881",
+        "treeHash": "0d32620317b29f94d6718684f030dd2fc2f30cb2",
+        "type": "github"
+      },
+      "original": {
+        "owner": "bobvanderlinden",
+        "repo": "nixpkgs-ruby",
+        "type": "github"
+      }
+    },
+    "nixpkgs-stable": {
+      "locked": {
+        "lastModified": 1710695816,
+        "narHash": "sha256-3Eh7fhEID17pv9ZxrPwCLfqXnYP006RKzSs0JptsN84=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "614b4613980a522ba49f0d194531beddbb7220d3",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-23.11",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_2": {
+      "locked": {
+        "lastModified": 1715542476,
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "44072e24566c5bcc0b7aa9178a0104f4cfffab19",
+        "treeHash": "3f9021e4c33de6fe59b88ac8c3019fc49136dc2a",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-23.11",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "pre-commit-hooks": {
+      "inputs": {
+        "flake-compat": "flake-compat_2",
+        "flake-utils": "flake-utils_2",
+        "gitignore": "gitignore",
+        "nixpkgs": [
+          "nixpkgs"
+        ],
+        "nixpkgs-stable": "nixpkgs-stable"
+      },
+      "locked": {
+        "lastModified": 1715609711,
+        "narHash": "sha256-/5u29K0c+4jyQ8x7dUIEUWlz2BoTSZWUP2quPwFCE7M=",
+        "owner": "cachix",
+        "repo": "pre-commit-hooks.nix",
+        "rev": "c182c876690380f8d3b9557c4609472ebfa1b141",
+        "type": "github"
+      },
+      "original": {
+        "owner": "cachix",
+        "repo": "pre-commit-hooks.nix",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "devenv": "devenv",
+        "nixpkgs": "nixpkgs",
+        "nixpkgs-ruby": "nixpkgs-ruby",
+        "pre-commit-hooks": "pre-commit-hooks"
+      }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "treeHash": "cce81f2a0f0743b2eb61bc2eb6c7adbe2f2c6beb",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    },
+    "systems_2": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

data/devenv.nix

@@ -0,0 +1,12 @@
+{ pkgs, ... }:
+
+{
+  packages = with pkgs; [
+    git
+    libyaml
+  ];
+
+
+  languages.ruby.enable = true;
+  languages.ruby.version = "3.1.5";
+}

data/devenv.yaml

@@ -0,0 +1,6 @@
+allowUnfree: true
+inputs:
+  nixpkgs:
+    url: github:NixOS/nixpkgs/nixos-23.11
+  nixpkgs-ruby:
+    url: github:bobvanderlinden/nixpkgs-ruby

data/lib/azure_blob/blob.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module AzureBlob
+  class Blob
+    def initialize(response)
+      @response = response
+    end
+
+    def content_type
+      response.content_type
+    end
+
+    def content_disposition
+      response["content-disposition"]
+    end
+
+    def checksum
+      response["content-md5"]
+    end
+
+    def size
+      response.content_length
+    end
+
+    def present?
+      response.code == "200"
+    end
+
+    def metadata
+      @metadata || response
+        .to_hash
+        .select { |key, _| key.start_with?("x-ms-meta") }
+        .transform_values(&:first)
+        .transform_keys { |key| key.delete_prefix("x-ms-meta-").to_sym }
+    end
+
+    private
+
+    attr_reader :response
+  end
+end

data/lib/azure_blob/blob_list.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "rexml"
+
+module AzureBlob
+  class BlobList
+    include REXML
+    include Enumerable
+
+    def initialize(fetcher)
+      @fetcher = fetcher
+    end
+
+    def size
+      to_a.size
+    end
+
+    def each
+      loop do
+        fetch
+        current_page.each do |key|
+          yield key
+        end
+
+        break unless marker
+      end
+    end
+
+    def to_s
+      to_a.to_s
+    end
+
+    def inspect
+      to_a.inspect
+    end
+
+    private
+
+    def marker
+      document && document.get_elements("//EnumerationResults/NextMarker").first.get_text()&.to_s
+    end
+
+    def current_page
+      document
+        .get_elements("//EnumerationResults/Blobs/Blob/Name")
+        .map { |element| element.get_text.to_s }
+    end
+
+    def fetch
+      @document = Document.new(fetcher.call(marker))
+    end
+
+    attr_reader :document, :fetcher
+  end
+end

data/lib/azure_blob/block_list.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "rexml"
+
+module AzureBlob
+  class BlockList
+    include REXML
+    def initialize(blocks)
+      @blocks = blocks
+      @document = build_document
+    end
+
+    def to_s
+      document.to_s
+    end
+
+    private
+
+    attr_reader :blocks, :document
+
+    def build_document
+      document = Document.new
+      document.add(XMLDecl.new("1.0", "utf-8"))
+      block_list = document.add_element(Element.new("BlockList"))
+      blocks.each do |block_id|
+        block = block_list.add_element(Element.new("Latest"))
+        block.text = block_id
+      end
+      document
+    end
+  end
+end

data/lib/azure_blob/canonicalized_headers.rb

@@ -0,0 +1,19 @@
+module AzureBlob
+  class CanonicalizedHeaders
+    STANDARD_HEADERS = [
+      :"x-ms-version",
+    ]
+
+    def initialize(headers)
+      @cannonicalized_headers = headers
+        .transform_keys(&:downcase)
+        .select { |key, value| key.start_with? "x-ms-" }
+        .sort
+        .map { |header, value| "#{header}:#{value}" }
+    end
+
+    def to_s
+      @cannonicalized_headers.join("\n")
+    end
+  end
+end

data/lib/azure_blob/canonicalized_resource.rb

@@ -0,0 +1,23 @@
+require "cgi"
+
+module AzureBlob
+  class CanonicalizedResource
+    def initialize(uri, account_name, service_name: nil, url_safe: true)
+      # This next line is needed because CanonicalizedResource
+      # need to be escaped for auhthorization headers, but not SAS tokens
+      path = url_safe ? uri.path : URI::DEFAULT_PARSER.unescape(uri.path)
+      resource = "/#{account_name}#{path.empty? ? "/" : path}"
+      resource = "/#{service_name}#{resource}" if service_name
+      params = CGI.parse(uri.query.to_s)
+        .transform_keys(&:downcase)
+        .sort
+        .map { |param, value| "#{param}:#{value.map(&:strip).sort.join(",")}" }
+
+      @canonicalized_resource = [ resource, *params ].join("\n")
+    end
+
+    def to_s
+      @canonicalized_resource
+    end
+  end
+end

data/lib/azure_blob/client.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require_relative "signer"
+require_relative "block_list"
+require_relative "blob_list"
+require_relative "blob"
+require_relative "http"
+require "time"
+require "base64"
+
+module AzureBlob
+  class Client
+    def initialize(account_name:, access_key:, container:)
+      @account_name = account_name
+      @container = container
+      @signer = Signer.new(account_name:, access_key:)
+    end
+
+    def create_block_blob(key, content, options = {})
+      if content.size > (options[:block_size] || DEFAULT_BLOCK_SIZE)
+        put_blob_multiple(key, content, **options)
+      else
+        put_blob_single(key, content, **options)
+      end
+    end
+
+    def get_blob(key, options = {})
+      uri = generate_uri("#{container}/#{key}")
+
+      headers = {
+        "x-ms-range": options[:start] && "bytes=#{options[:start]}-#{options[:end]}",
+      }
+
+      Http.new(uri, headers, signer:).get
+    end
+
+    def delete_blob(key, options = {})
+      uri = generate_uri("#{container}/#{key}")
+
+      headers = {
+        "x-ms-delete-snapshots": options[:delete_snapshots] || "include",
+      }
+
+      Http.new(uri, headers, signer:).delete
+    end
+
+    def delete_prefix(prefix, options = {})
+      results = list_blobs(prefix:)
+      results.each { |key| delete_blob(key) }
+    end
+
+    def list_blobs(options = {})
+      uri = generate_uri(container)
+      query = {
+        comp: "list",
+        restype: "container",
+        prefix: options[:prefix].to_s.gsub(/\\/, "/"),
+      }
+      query[:maxresults] = options[:max_results] if options[:max_results]
+      uri.query = URI.encode_www_form(**query)
+
+      fetcher = ->(marker) do
+        query[:marker] = marker
+        query.reject! { |key, value| value.to_s.empty? }
+        uri.query = URI.encode_www_form(**query)
+        response = Http.new(uri, signer:).get
+      end
+
+      BlobList.new(fetcher)
+    end
+
+    def get_blob_properties(key, options = {})
+      uri = generate_uri("#{container}/#{key}")
+
+      response = Http.new(uri, signer:).head
+
+      Blob.new(response)
+    end
+
+    def generate_uri(path)
+      URI.parse(URI::DEFAULT_PARSER.escape(File.join(host, path)))
+    end
+
+    def signed_uri(key, permissions:, expiry:, **options)
+      uri = generate_uri("#{container}/#{key}")
+      uri.query = signer.sas_token(uri, permissions:, expiry:, **options)
+      uri
+    end
+
+    def create_append_blob(key, options = {})
+      uri = generate_uri("#{container}/#{key}")
+
+      headers = {
+        "x-ms-blob-type": "AppendBlob",
+        "Content-Length": 0,
+        "Content-Type": options[:content_type],
+        "Content-MD5": options[:content_md5],
+        "x-ms-blob-content-disposition": options[:content_disposition],
+      }
+
+      Http.new(uri, headers, metadata: options[:metadata], signer:).put(nil)
+    end
+
+    def append_blob_block(key, content, options = {})
+      uri = generate_uri("#{container}/#{key}")
+      uri.query = URI.encode_www_form(comp: "appendblock")
+
+      headers = {
+        "Content-Length": content.size,
+        "Content-Type": options[:content_type],
+        "Content-MD5": options[:content_md5],
+      }
+
+      Http.new(uri, headers, signer:).put(content)
+    end
+
+    def put_blob_block(key, index, content, options = {})
+      block_id = generate_block_id(index)
+      uri = generate_uri("#{container}/#{key}")
+      uri.query = URI.encode_www_form(comp: "block", blockid: block_id)
+
+      headers = {
+        "Content-Length": content.size,
+        "Content-Type": options[:content_type],
+        "Content-MD5": options[:content_md5],
+      }
+
+      Http.new(uri, headers, signer:).put(content)
+
+      block_id
+    end
+
+    def commit_blob_blocks(key, block_ids, options = {})
+      block_list = BlockList.new(block_ids)
+      content = block_list.to_s
+      uri = generate_uri("#{container}/#{key}")
+      uri.query = URI.encode_www_form(comp: "blocklist")
+
+      headers = {
+        "Content-Length": content.size,
+        "Content-Type": options[:content_type],
+        "Content-MD5": options[:content_md5],
+        "x-ms-blob-content-disposition": options[:content_disposition],
+      }
+
+      Http.new(uri, headers, metadata: options[:metadata], signer:).put(content)
+    end
+
+    private
+
+    def generate_block_id(index)
+      Base64.urlsafe_encode64(index.to_s.rjust(6, "0"))
+    end
+
+    def put_blob_multiple(key, content, options = {})
+      content = StringIO.new(content) if content.is_a? String
+      block_size = options[:block_size] || DEFAULT_BLOCK_SIZE
+      block_count = (content.size.to_f / block_size).ceil
+      block_ids = block_count.times.map do |i|
+        put_blob_block(key, i, content.read(block_size))
+      end
+
+      commit_blob_blocks(key, block_ids, options)
+    end
+
+    def put_blob_single(key, content, options = {})
+      content = StringIO.new(content) if content.is_a? String
+      uri = generate_uri("#{container}/#{key}")
+
+      headers = {
+        "x-ms-blob-type": "BlockBlob",
+        "Content-Length": content.size,
+        "Content-Type": options[:content_type],
+        "Content-MD5": options[:content_md5],
+        "x-ms-blob-content-disposition": options[:content_disposition],
+      }
+
+      Http.new(uri, headers, metadata: options[:metadata], signer:).put(content.read)
+    end
+
+    attr_reader :account_name, :signer, :container, :http
+
+    def host
+      "https://#{account_name}.blob.core.windows.net"
+    end
+  end
+end

data/lib/azure_blob/const.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module AzureBlob
+  API_VERSION = "2024-05-04"
+  MAX_UPLOAD_SIZE = 256 * 1024 * 1024
+  DEFAULT_BLOCK_SIZE = 128 * 1024 * 1024
+  BLOB_SERVICE = "b"
+end

data/lib/azure_blob/errors.rb

@@ -0,0 +1,3 @@
+module AzureBlob
+  class Error < StandardError; end
+end

data/lib/azure_blob/http.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+require_relative "metadata"
+require "net/http"
+require "rexml"
+
+module AzureBlob
+  class Http
+    class Error < AzureBlob::Error; end
+    class FileNotFoundError < Error; end
+    class ForbidenError < Error; end
+    class IntegrityError < Error; end
+
+    include REXML
+
+    def initialize(uri, headers = {}, signer: nil, metadata: {}, debug: false)
+      @date = Time.now.httpdate
+      @uri = uri
+      @signer = signer
+      @headers = headers.merge(Metadata.new(metadata).headers)
+      sanitize_headers
+
+      @http = Net::HTTP.new(uri.hostname, uri.port)
+      @http.use_ssl = uri.port == 443
+      @http.set_debug_output($stdout) if debug
+    end
+
+    def get
+      sign_request("GET") if signer
+      @response = http.start do |http|
+        http.get(uri, headers)
+      end
+      raise_error  unless success?
+      response.body
+    end
+
+    def put(content)
+      sign_request("PUT") if signer
+      @response = http.start do |http|
+        http.put(uri, content, headers)
+      end
+      raise_error  unless success?
+      true
+    end
+
+    def head
+      sign_request("HEAD") if signer
+      @response = http.start do |http|
+        http.head(uri, headers)
+      end
+      raise_error  unless success?
+      response
+    end
+
+    def delete
+      sign_request("DELETE") if signer
+      @response = http.start do |http|
+        http.delete(uri, headers)
+      end
+      raise_error  unless success?
+      response.body
+    end
+
+    def success?
+      status < Net::HTTPSuccess
+    end
+
+    private
+
+    ERROR_MAPPINGS = {
+      Net::HTTPNotFound => FileNotFoundError,
+      Net::HTTPForbidden => ForbidenError,
+    }
+
+    ERROR_CODE_MAPPINGS = {
+      "Md5Mismatch" => IntegrityError,
+    }
+
+    def sanitize_headers
+      headers[:"x-ms-version"] =  API_VERSION
+      headers[:"x-ms-date"] = date
+      headers[:"Content-Type"] = headers[:"Content-Type"].to_s
+      headers[:"Content-Length"] = headers[:"Content-Length"]&.to_s
+      headers[:"Content-MD5"] = nil if headers[:"Content-MD5"]&.empty?
+      headers.reject! { |_, value| value.nil? }
+    end
+
+    def sign_request(method)
+      headers[:Authorization] = signer.authorization_header(uri:, verb: method, headers:)
+    end
+
+    def raise_error
+      raise error_from_response.new(@response.body)
+    end
+
+    def status
+      @status ||= Net::HTTPResponse::CODE_TO_OBJ[response.code]
+    end
+
+    def azure_error_code
+      Document.new(response.body).get_elements("//Error/Code").first.get_text.to_s
+    end
+
+    def error_from_response
+      ERROR_MAPPINGS[status] || ERROR_CODE_MAPPINGS[azure_error_code] || Error
+    end
+
+    attr_accessor :host, :http, :signer, :response, :headers, :uri, :date
+  end
+end

data/lib/azure_blob/metadata.rb

@@ -0,0 +1,12 @@
+module AzureBlob
+  class Metadata
+    def initialize(metadata = nil)
+      @metadata = metadata || {}
+      @headers = @metadata.map do |key, value|
+        [ :"x-ms-meta-#{key}", value.to_s ]
+      end.to_h
+    end
+
+    attr_reader :headers
+  end
+end

data/lib/azure_blob/signer.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "base64"
+require "openssl"
+require_relative "canonicalized_headers"
+require_relative "canonicalized_resource"
+
+module AzureBlob
+  class Signer
+    def initialize(account_name:, access_key:)
+      @account_name = account_name
+      @access_key = Base64.decode64(access_key)
+    end
+
+    def authorization_header(uri:, verb:, headers: {})
+      canonicalized_headers = CanonicalizedHeaders.new(headers)
+      canonicalized_resource = CanonicalizedResource.new(uri, account_name)
+
+      to_sign = [
+        verb,
+        *sanitize_headers(headers).fetch_values(
+          :"Content-Encoding",
+          :"Content-Language",
+          :"Content-Length",
+          :"Content-MD5",
+          :"Content-Type",
+          :"Date",
+          :"If-Modified-Since",
+          :"If-Match",
+          :"If-None-Match",
+          :"If-Unmodified-Since",
+          :"Range"
+        ) { nil },
+        canonicalized_headers,
+        canonicalized_resource,
+      ].join("\n")
+
+      "SharedKey #{account_name}:#{sign(to_sign)}"
+    end
+
+    def sas_token(uri, options = {})
+      to_sign = [
+        options[:permissions],
+        options[:start],
+        options[:expiry],
+        CanonicalizedResource.new(uri, account_name, url_safe: false, service_name: :blob),
+        options[:identifier],
+        options[:ip],
+        options[:protocol],
+        SAS::Version,
+        SAS::Resources::Blob,
+        nil,
+        nil,
+        nil,
+        options[:content_disposition],
+        nil,
+        nil,
+        options[:content_type],
+      ].join("\n")
+
+      query = {
+        SAS::Fields::Permissions => options[:permissions],
+        SAS::Fields::Version => SAS::Version,
+        SAS::Fields::Expiry => options[:expiry],
+        SAS::Fields::Resource => SAS::Resources::Blob,
+        SAS::Fields::Disposition => options[:content_disposition],
+        SAS::Fields::Type => options[:content_type],
+        SAS::Fields::Signature => sign(to_sign),
+      }.reject { |_, value| value.nil? }
+
+      URI.encode_www_form(**query)
+    end
+
+    def sign(body)
+      Base64.strict_encode64(OpenSSL::HMAC.digest("sha256", access_key, body))
+    end
+
+    private
+
+    def sanitize_headers(headers)
+      headers = headers.dup
+      headers[:"Content-Length"] = nil if headers[:"Content-Length"].to_i == 0
+      headers
+    end
+
+    module SAS
+      Version = "2024-05-04"
+      module Fields
+        Permissions = :sp
+        Version = :sv
+        Expiry = :se
+        Resource = :sr
+        Signature = :sig
+        Disposition = :rscd
+        Type = :rsct
+      end
+      module Resources
+        Blob = :b
+      end
+    end
+
+    attr_reader :access_key, :account_name
+  end
+end

data/lib/azure_blob/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module AzureBlob
+  VERSION = "0.3.0"
+end

data/lib/azure_blob.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "azure_blob/version"
+require_relative "azure_blob/client"
+require_relative "azure_blob/const"
+require_relative "azure_blob/errors"
+
+module AzureBlob
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: azure-blob
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Joé Dupuis
+autorequire:
+bindir: exe
+cert_chain: []
+date: 1980-01-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rexml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description:
+email:
+- joe@dupuis.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".envrc"
+- ".rubocop.yml"
+- ".standard.yml"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- azure-blob.gemspec
+- devenv.lock
+- devenv.nix
+- devenv.yaml
+- lib/azure_blob.rb
+- lib/azure_blob/blob.rb
+- lib/azure_blob/blob_list.rb
+- lib/azure_blob/block_list.rb
+- lib/azure_blob/canonicalized_headers.rb
+- lib/azure_blob/canonicalized_resource.rb
+- lib/azure_blob/client.rb
+- lib/azure_blob/const.rb
+- lib/azure_blob/errors.rb
+- lib/azure_blob/http.rb
+- lib/azure_blob/metadata.rb
+- lib/azure_blob/signer.rb
+- lib/azure_blob/version.rb
+homepage: https://github.com/JoeDupuis/azure-blob
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/JoeDupuis/azure-blob
+  source_code_uri: https://github.com/JoeDupuis/azure-blob
+  changelog_uri: https://github.com/JoeDupuis/azure-blob/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.27
+signing_key:
+specification_version: 4
+summary: Azure blob client
+test_files: []