archivault 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 18e7063c221d22627d0355b857c7bd767d14cd2312f2c04391c506cba4ba1689
+  data.tar.gz: 2b5649d48fc0eb996bc8377f7670ad1d576cfe18609363079653472f92bea66c
+SHA512:
+  metadata.gz: 2de400dc93463d3dd8247eaecdb9a323c59001106e1ad41d145dba5b68d50f03ec8ab2bde6fb7b98b128280a2dee21439bb4340d5a068810f654b91f586b488a
+  data.tar.gz: 9a41e8bec7f152ba8ee845e5387dfabcda6f7055ba770c012d1143da1ac81454039d20448b5b74e77527859100f51a21d0582f3af685bbe6187fcd193789fac2

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2026-04-08
+
+- Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,10 @@
+# Code of Conduct
+
+"archivault" follows [The Ruby Community Conduct Guideline](https://www.ruby-lang.org/en/conduct) in all "collaborative space", which is defined as community communications channels (such as mailing lists, submitted patches, commit comments, etc.):
+
+* Participants will be tolerant of opposing views.
+* Participants must ensure that their language and actions are free of personal attacks and disparaging personal remarks.
+* When interpreting the words and actions of others, participants should always assume good intentions.
+* Behaviour which can be reasonably considered harassment will not be tolerated.
+
+If you have any concerns about behaviour within this project, please contact us at ["piotr@macuk.pl"](mailto:"piotr@macuk.pl").

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Piotr Macuk
+
+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,112 @@
+# Archivault
+
+ArchiVault is a Ruby gem for Rails applications that backs up files, logs, and databases
+using paths and credentials provided by the app. It compresses and encrypts the data,
+then uploads it securely to AWS S3.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add archivault
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install archivault
+```
+
+## Ruby usage
+
+### SQLite database backup
+
+```ruby
+database_path = "/home/user/app/storage/production.sqlite3"
+gpg_passphrase = "password"
+s3_setup = { 
+  region: "region", 
+  access_key_id: "access_key_id",  
+  secret_access_key: "secret_access_key", 
+  bucket: "bucket"
+}
+ping_url = "https://example.com/ping" # optional parameter
+
+Archivault::SqliteBackup.new(database_path:, gpg_passphrase:, s3_setup:, ping_url:).call
+```
+
+### Logs backup
+
+```ruby
+log_path_or_paths = %w[
+  /home/user/app/log/production.log.1
+  /home/user/app/log/nginx_access.log.1
+]
+gpg_passphrase = "password"
+s3_setup = { 
+  region: "region", 
+  access_key_id: "access_key_id",  
+  secret_access_key: "secret_access_key", 
+  bucket: "bucket"
+}
+ping_url = "https://example.com/ping" # optional parameter
+
+Archivault::LogsBackup.new(log_path_or_paths:, gpg_passphrase:, s3_setup:, ping_url:).call
+```
+
+## Rais usage
+
+### SQLite database backup
+
+```ruby
+# in config/credentials.yml.enc 
+# archivault:
+#   gpg_passphrase: password
+#   s3_setup:
+#     region: region
+#     access_key_id: access_key_id
+#     secret_access_key: secret_access_key
+#     bucket: bucket
+params = {
+  database_path: Rails.root.join("storage/production.sqlite3"),
+  ping_url: "https://example.com/ping" # optional parameter
+}.merge(Rails.application.credentials.archivault)
+Archivault::SqliteBackup.new(**params).call
+```
+
+### Logs backup
+
+```ruby
+# in config/credentials.yml.enc 
+# archivault:
+#   gpg_passphrase: password
+#   s3_setup:
+#     region: region
+#     access_key_id: access_key_id
+#     secret_access_key: secret_access_key
+#     bucket: bucket
+params = {
+  log_path_or_paths: Rails.root.join("log", "production.log.1"),
+  ping_url: "https://example.com/ping" # optional parameter
+}.merge(Rails.application.credentials.archivault)
+Archivault::LogsBackup.new(**params).call
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/macuk/archivault. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/macuk/archivault/blob/main/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Archivault project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/macuk/archivault/blob/main/CODE_OF_CONDUCT.md).

data/Rakefile

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

data/lib/archivault/clean.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Archivault
+  class Clean
+    def initialize(path_or_paths)
+      @paths = Array(path_or_paths)
+      raise ArgumentError, "path_or_paths is required" if @paths.empty?
+    end
+
+    def call
+      @paths.each do |path|
+        raise ArgumentError, "path is required" if path.nil? || path.to_s.empty?
+
+        FileUtils.rm_f(path.to_s)
+      end
+    end
+  end
+end

data/lib/archivault/execute.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "English"
+
+module Archivault
+  class Execute
+    def call(command, *)
+      status = system(command, *)
+      raise ExecuteError, "#{command} could not be executed" if status.nil?
+      raise ExecuteError, "#{command} failed with exit code #{$CHILD_STATUS&.exitstatus}" unless status
+
+      status
+    end
+  end
+end

data/lib/archivault/gpg.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Archivault
+  class Gpg
+    def initialize(file_path)
+      raise ArgumentError, "file_path is required" if file_path.nil? || file_path.to_s.empty?
+
+      @file_path = file_path.to_s
+    end
+
+    def call(passphrase)
+      raise ArgumentError, "passphrase is required" if passphrase.to_s.strip.empty?
+
+      Execute.new.call(
+        "gpg",
+        "--batch",
+        "--yes",
+        "--symmetric",
+        "--cipher-algo", "AES256",
+        "--passphrase", passphrase,
+        @file_path
+      )
+    end
+  end
+end

data/lib/archivault/logs_backup.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Archivault
+  class LogsBackup
+    # Parameters
+    #   - log_path_or_paths: Path or array of paths to the log files to back up
+    #   - gpg_passphrase: GPG passphrase to encrypt the backup file
+    #   - s3_setup: Hash of S3 setup options:
+    #     - region: AWS region
+    #     - access_key_id: AWS access key ID
+    #     - secret_access_key: AWS secret access key
+    #     - bucket: S3 bucket name
+    def initialize(log_path_or_paths:, gpg_passphrase:, s3_setup:, ping_url: nil)
+      @log_path_or_paths = log_path_or_paths
+      @gpg_passphrase = gpg_passphrase.to_s
+      @s3_setup = s3_setup
+      @ping_url = ping_url
+
+      @timestamp = Timestamp.new.timestamp
+      @tmp_path = Tmp.new.path
+      @tar_path = "#{@tmp_path}/logs-#{@timestamp}.tgz"
+      @gpg_path = "#{@tar_path}.gpg"
+    end
+
+    def call
+      Tar.new(tar_path: @tar_path, path_or_paths: @log_path_or_paths).call
+      Gpg.new(@tar_path).call(@gpg_passphrase)
+      S3.new(@gpg_path).call(**@s3_setup)
+      Ping.new(@ping_url).call if @ping_url
+    ensure
+      Clean.new([@tar_path, @gpg_path]).call
+    end
+  end
+end

data/lib/archivault/ping.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Archivault
+  class Ping
+    def initialize(ping_url)
+      raise ArgumentError, "ping_url is required" if ping_url.nil? || ping_url.to_s.empty?
+
+      @ping_url = ping_url.to_s
+    end
+
+    def call
+      Net::HTTP.get_response(URI(@ping_url))
+    end
+  end
+end

data/lib/archivault/s3.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "aws-sdk-s3"
+
+module Archivault
+  class S3
+    def initialize(file_path)
+      raise ArgumentError, "file_path is required" if file_path.nil? || file_path.to_s.empty?
+
+      @file_path = file_path.to_s
+    end
+
+    def call(region:, access_key_id:, secret_access_key:, bucket:)
+      validate_call_arguments!(region:, access_key_id:, secret_access_key:, bucket:)
+
+      basename = File.basename(@file_path)
+      bucket_path = basename.sub(/^(.+)-(\d{4})-(\d{2}).*/, '\1/\2/\3/')
+      key = bucket_path + basename
+
+      s3_client = Aws::S3::Client.new(region:, access_key_id:, secret_access_key:)
+      transfer_manager = Aws::S3::TransferManager.new(client: s3_client)
+      status = transfer_manager.upload_file(
+        @file_path, bucket:, key:, storage_class: "STANDARD_IA"
+      )
+      raise S3Error, "Failed AWS S3 upload command" unless status
+    end
+
+    private
+
+    def validate_call_arguments!(region:, access_key_id:, secret_access_key:, bucket:)
+      {
+        region:,
+        access_key_id:,
+        secret_access_key:,
+        bucket:
+      }.each do |name, value|
+        raise ArgumentError, "#{name} is required" if value.nil? || value.to_s.empty?
+      end
+    end
+  end
+end

data/lib/archivault/sqlite.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Archivault
+  class Sqlite
+    def initialize(database_path:, backup_path:)
+      raise ArgumentError, "database_path is required" if database_path.nil? || database_path.to_s.empty?
+      raise ArgumentError, "backup_path is required" if backup_path.nil? || backup_path.to_s.empty?
+
+      @database_path = database_path.to_s
+      @backup_path = backup_path.to_s
+    end
+
+    def call
+      Execute.new.call("sqlite3", @database_path, %(.backup "#{@backup_path}"))
+    end
+  end
+end

data/lib/archivault/sqlite_backup.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Archivault
+  class SqliteBackup
+    # Parameters
+    #   - database_path: Path to the SQLite3 database file
+    #   - gpg_passphrase: GPG passphrase to encrypt the backup file
+    #   - s3_setup: Hash of S3 setup options:
+    #     - region: AWS region
+    #     - access_key_id: AWS access key ID
+    #     - secret_access_key: AWS secret access key
+    #     - bucket: S3 bucket name
+    def initialize(database_path:, gpg_passphrase:, s3_setup:, ping_url: nil)
+      @database_path = database_path.to_s
+      @gpg_passphrase = gpg_passphrase.to_s
+      @s3_setup = s3_setup
+      @ping_url = ping_url
+
+      @timestamp = Timestamp.new.timestamp
+      @tmp_path = Tmp.new.path
+      @backup_path = "#{@tmp_path}/database-#{@timestamp}.sqlite3"
+      @tar_path = "#{@tmp_path}/database-#{@timestamp}.tgz"
+      @gpg_path = "#{@tar_path}.gpg"
+    end
+
+    def call
+      Sqlite.new(database_path: @database_path, backup_path: @backup_path).call
+      Tar.new(tar_path: @tar_path, path_or_paths: @backup_path).call
+      Gpg.new(@tar_path).call(@gpg_passphrase)
+      S3.new(@gpg_path).call(**@s3_setup)
+      Ping.new(@ping_url).call if @ping_url
+    ensure
+      Clean.new([@backup_path, @tar_path, @gpg_path]).call
+    end
+  end
+end

data/lib/archivault/tar.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Archivault
+  class Tar
+    def initialize(tar_path:, path_or_paths:)
+      raise ArgumentError, "tar_path is required" if tar_path.nil? || tar_path.to_s.empty?
+
+      @tar_path = tar_path.to_s
+
+      @paths = Array(path_or_paths)
+      raise ArgumentError, "path_or_paths is required" if @paths.empty?
+    end
+
+    def call
+      @paths.each do |path|
+        raise ArgumentError, "path is required" if path.nil? || path.to_s.empty?
+      end
+
+      Execute.new.call("tar", "-czf", @tar_path, *@paths.map(&:to_s), out: File::NULL, err: File::NULL)
+    end
+  end
+end

data/lib/archivault/timestamp.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Archivault
+  class Timestamp
+    attr_reader :timestamp
+
+    def initialize
+      @timestamp = Time.now.strftime("%Y-%m-%d-%H-%M")
+    end
+  end
+end

data/lib/archivault/tmp.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Archivault
+  class Tmp
+    attr_reader :path
+
+    def initialize(path = "/tmp")
+      @path = defined?(Rails) ? Rails.root.join("tmp").to_s : path
+    end
+  end
+end

data/lib/archivault/version.rb

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

data/lib/archivault.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "archivault/version"
+require_relative "archivault/timestamp"
+require_relative "archivault/execute"
+require_relative "archivault/sqlite"
+require_relative "archivault/clean"
+require_relative "archivault/tar"
+require_relative "archivault/tmp"
+require_relative "archivault/gpg"
+require_relative "archivault/s3"
+require_relative "archivault/ping"
+require_relative "archivault/sqlite_backup"
+require_relative "archivault/logs_backup"
+
+module Archivault
+  class Error < StandardError; end
+  class ExecuteError < Error; end
+  class S3Error < Error; end
+  # Your code goes here...
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: archivault
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Piotr Macuk
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-s3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.219'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.219'
+- !ruby/object:Gem::Dependency
+  name: rexml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+description: ArchiVault is a Ruby gem for Rails applications that backs up files,
+  logs, and databases using paths and credentials provided by the app. It compresses
+  and encrypts the data, then uploads it securely to AWS S3.
+email:
+- piotr@macuk.pl
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/archivault.rb
+- lib/archivault/clean.rb
+- lib/archivault/execute.rb
+- lib/archivault/gpg.rb
+- lib/archivault/logs_backup.rb
+- lib/archivault/ping.rb
+- lib/archivault/s3.rb
+- lib/archivault/sqlite.rb
+- lib/archivault/sqlite_backup.rb
+- lib/archivault/tar.rb
+- lib/archivault/timestamp.rb
+- lib/archivault/tmp.rb
+- lib/archivault/version.rb
+homepage: https://github.com/macuk/archivault
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/macuk/archivault
+  source_code_uri: https://github.com/macuk/archivault
+  changelog_uri: https://github.com/macuk/archivault/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.9
+specification_version: 4
+summary: Rails backup gem for compressing, encrypting, and uploading data to AWS S3.
+test_files: []