beam_up 0.5.0

data/lib/beam_up/providers/hetzner.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "beam_up/providers/s3_compatible"
+
+module BeamUp
+  module Providers
+    class Hetzner < S3Compatible
+      class Config
+        def self.config_keys = %w[access_key secret_key region bucket]
+
+        attr_accessor :access_key, :secret_key, :region, :bucket
+
+        def with(options)
+          self.access_key = options[:access_key]
+          self.secret_key = options[:secret_key]
+          self.region = options[:region] || "fsn1"
+          self.bucket = options[:bucket]
+          self
+        end
+
+        def validate!
+          raise ConfigurationError, "Access key must be set" unless access_key
+          raise ConfigurationError, "Secret key must be set" unless secret_key
+          raise ConfigurationError, "Bucket must be set" unless bucket
+          raise ConfigurationError, "Invalid region: #{region}. Valid regions: fsn1, nbg1, hel1, ash, hil, sin" unless VALID_REGIONS.include?(region)
+        end
+      end
+
+      private
+
+      VALID_REGIONS = %w[ash fsn1 hel1 hil nbg1 sin]
+
+      def bucket_name = @configuration.bucket
+
+      def endpoint = "https://#{@configuration.region}.your-objectstorage.com"
+
+      def public_url = "https://#{bucket_name}.#{@configuration.region}.your-objectstorage.com"
+
+      def provider_name = "Hetzner"
+    end
+  end
+end

data/lib/beam_up/providers/neocities.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+
+module BeamUp
+  module Providers
+    class Neocities < Base
+      API_HOST = "https://neocities.org"
+
+      class Config
+        def self.config_keys = %w[api_key site_name]
+
+        attr_accessor :api_key, :site_name
+
+        def with(options)
+          self.api_key = options[:api_key]
+          self.site_name = options[:site_name]
+          self
+        end
+
+        def validate!
+          raise ConfigurationError, "API key must be set" unless api_key
+          raise ConfigurationError, "Site name must be set" unless site_name
+        end
+      end
+
+      def deploy!(path)
+        @path = path
+
+        upload_files
+
+        Result.new(
+          provider: "Neocities",
+          deploy_id: Time.now.to_i.to_s,
+          url: "https://#{@configuration.site_name}.neocities.org"
+        )
+      rescue => error
+        Result.new(provider: "Neocities", error: error.message)
+      end
+
+      private
+
+      def upload_files
+        uri = URI("#{API_HOST}/api/upload")
+
+        request = Net::HTTP::Post.new(uri)
+        request.basic_auth(@configuration.site_name, @configuration.api_key)
+
+        form_data = files_to_deploy.map do |file|
+          relative_path = file.delete_prefix("#{@path}/")
+
+          [relative_path, File.read(file)]
+        end
+
+        request.set_form(form_data, "multipart/form-data")
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(request)
+        end
+
+        case response.code.to_i
+        when 200..299
+          json_response = JSON.parse(response.body)
+          raise DeploymentError, json_response["message"] if json_response["result"] == "error"
+        else
+          raise DeploymentError, "Neocities API error: #{response.code} #{response.body}"
+        end
+      end
+    end
+  end
+end

data/lib/beam_up/providers/netlify.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "digest"
+require "cgi/escape"
+require "net/http"
+require "json"
+
+module BeamUp
+  module Providers
+    class Netlify < Base
+      class Config
+        def self.config_keys = %w[api_token project_id]
+
+        attr_accessor :api_token, :project_id
+
+        def with(options)
+          self.api_token = options[:api_token]
+          self.project_id = options[:project_id]
+          self
+        end
+
+        def validate!
+          raise ConfigurationError, "API token must be set" unless api_token
+        end
+      end
+
+      def deploy!(path)
+        @path = path
+        digested_files = digested files_to_deploy
+        response = post "/sites/#{project_id}/deploys", files: digested_files
+
+        upload(files_to_deploy, response)
+
+        Result.new(
+          provider: "Netlify",
+          deploy_id: response["id"],
+          url: response["deploy_ssl_url"] || response["ssl_url"]
+        )
+      rescue => error
+        Result.new(provider: "Netlify", error: error.message)
+      end
+
+      private
+
+      def digested(files)
+        files.to_h do |file|
+          relative_path = "/#{file.delete_prefix("#{@path}/")}"
+
+          [relative_path, Digest::SHA1.hexdigest(File.read(file))]
+        end
+      end
+
+      def project_id
+        return @configuration.project_id if @configuration.project_id.to_s != ""
+
+        site_name = "#{File.basename(Dir.pwd)}-#{Time.now.to_i}"
+        site = post("/sites", {name: [site_name, SecureRandom.hex(4)].join("-")})
+        @created_project_id = site["id"]
+      end
+
+      def upload(files, response)
+        required_shas = response["required"] || []
+        return if required_shas.empty?
+
+        required_shas.each.with_index(1) do |sha, index|
+          file_path = file_map_from(files)[sha]
+          next if file_path.nil? || file_path.empty?
+
+          relative_path = "/" + file_path.delete_prefix("#{@path}/")
+          escaped_path = CGI.escape(relative_path.delete_prefix("/"))
+
+          put("/deploys/#{response["id"]}/files/#{escaped_path}", File.read(file_path))
+        end
+      end
+
+      def message
+        if @configuration.project_id.to_s.empty?
+          <<~MSG
+            Successfully deployed to Netlify.
+
+            New site created with ID: #{@created_project_id}
+            Add this to your .beam_up.yml to skip site creation in future deploys:
+              project_id: #{@created_project_id}
+          MSG
+        else
+          "Successfully deployed to Netlify"
+        end
+      end
+
+      def file_map_from(files)
+        files.to_h { [Digest::SHA1.hexdigest(File.read(it)), it] }
+      end
+
+      def post(path, data)
+        request(:post, path, data.to_json, "application/json")
+      end
+
+      def put(path, data)
+        request(:put, path, data, "application/octet-stream")
+      end
+
+      def request(method, path, body = nil, content_type = nil)
+        uri = URI("https://api.netlify.com/api/v1#{path}")
+
+        request = case method
+        when :post then Net::HTTP::Post.new(uri)
+        when :put then Net::HTTP::Put.new(uri)
+        end
+
+        request["Authorization"] = "Bearer #{@configuration.api_token}"
+        request["Content-Type"] = content_type if content_type
+        request.body = body if body
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
+
+        case response.code.to_i
+        when 200..299
+          response.body.empty? ? {} : JSON.parse(response.body)
+        else
+          raise DeploymentError, "Netlify API error: #{response.code} #{response.body}"
+        end
+      end
+    end
+  end
+end

data/lib/beam_up/providers/s3_compatible.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "aws-sdk-s3"
+
+module BeamUp
+  module Providers
+    class S3Compatible < Base
+      def deploy!(path)
+        @path = path
+
+        files_to_deploy.each do |file|
+          upload file.delete_prefix("#{@path}/"), file
+        end
+
+        Result.new(
+          provider: provider_name,
+          deploy_id: Time.now.to_i.to_s,
+          url: public_url
+        )
+      rescue => error
+        Result.new(provider: provider_name, error: error.message)
+      end
+
+      private
+
+      def upload(key, file)
+        File.open(file, "rb") do |opened_file|
+          s3_client.put_object(
+            bucket: bucket_name,
+            key: key,
+            body: opened_file,
+            acl: "public-read"
+          )
+        end
+      end
+
+      def s3_client
+        @s3_client ||= Aws::S3::Client.new(
+          access_key_id: @configuration.access_key,
+          secret_access_key: @configuration.secret_key,
+          region: @configuration.region,
+          endpoint: endpoint
+        )
+      end
+
+      def bucket_name
+        raise NotImplementedError, "Subclasses must implement #bucket_name"
+      end
+
+      def endpoint
+        raise NotImplementedError, "Subclasses must implement #endpoint"
+      end
+
+      def public_url
+        raise NotImplementedError, "Subclasses must implement #public_url"
+      end
+
+      def provider_name
+        raise NotImplementedError, "Subclasses must implement #provider_name"
+      end
+    end
+  end
+end

data/lib/beam_up/providers/sftp.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module BeamUp
+  module Providers
+    class SFTP < Base
+      class Config
+        def self.config_keys = %w[host port username password key remote_path]
+
+        attr_accessor :host, :port, :username, :password, :key, :remote_path
+
+        def with(options)
+          self.host = options[:host]
+          self.port = options[:port] || 22
+          self.username = options[:username]
+          self.password = options[:password]
+          self.key = options[:key]
+          self.remote_path = options[:remote_path]
+          self
+        end
+
+        def validate!
+          raise ConfigurationError, "Host must be set" unless host
+          raise ConfigurationError, "Username must be set" unless username
+          raise ConfigurationError, "Remote path must be set" unless remote_path
+          raise ConfigurationError, "Password or key must be set" unless password || key
+        end
+      end
+
+      def deploy!(path)
+        @path = path
+
+        require "net/ssh"
+        require "net/sftp"
+
+        options = {
+          password: @configuration.password,
+          encryption: ["aes256-gcm@openssh.com", "aes256-ctr", "aes192-ctr", "aes128-ctr", "twofish256-ctr", "twofish192-ctr", "twofish128-ctr"]
+        }
+        options[:keys] = [@configuration.key] if @configuration.key
+
+        Net::SFTP.start(@configuration.host, @configuration.username, options) do |sftp|
+          files_to_deploy.each do |file|
+            upload sftp, file
+          end
+        end
+
+        Result.new(
+          provider: "SFTP",
+          deploy_id: Time.now.to_i.to_s,
+          url: "sftp://#{@configuration.host}#{@configuration.remote_path}"
+        )
+      rescue LoadError
+        raise ConfigurationError, "SFTP requires net-sftp gem. Install with: gem install net-sftp (or add to Gemfile)"
+      rescue => error
+        Result.new(provider: "SFTP", error: error.message)
+      end
+
+      private
+
+      def upload(sftp, file)
+        remote_path = File.join(@configuration.remote_path, file.delete_prefix("#{@path}/"))
+
+        return if unchanged?(sftp, file, remote_path)
+
+        sftp.upload(file, remote_path)
+      end
+
+      def unchanged?(sftp, file, remote_path)
+        size = File.size(file)
+
+        begin
+          remote_stat = sftp.stat!(remote_path)
+
+          remote_stat.size == size
+        rescue Net::SFTP::StatusException
+          false
+        end
+      end
+    end
+  end
+end

data/lib/beam_up/providers/statichost.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "zip"
+require "tempfile"
+
+module BeamUp
+  module Providers
+    class Statichost < Base
+      BUILDER_HOST = "https://builder.statichost.eu"
+
+      class Config
+        def self.config_keys = %w[api_key site_name builder_host]
+
+        attr_accessor :api_key, :site_name, :builder_host
+
+        def with(options)
+          self.api_key = options[:api_key]
+          self.site_name = options[:site_name]
+          self
+        end
+
+        def validate!
+          raise ConfigurationError, "API key must be set" unless api_key
+          raise ConfigurationError, "Site name must be set" unless site_name
+        end
+      end
+
+      def deploy!(path)
+        @path = path
+
+        zipped_file = create_zip path
+        response = upload zipped_file
+
+        Result.new(
+          provider: "Statichost",
+          deploy_id: response["id"] || Time.now.to_i.to_s,
+          url: "https://#{@configuration.site_name}.statichost.eu"
+        )
+      rescue => error
+        Result.new(provider: "Statichost", error: error.message)
+      ensure
+        zipped_file&.close!
+      end
+
+      private
+
+      def create_zip(path)
+        temp = Tempfile.new(["statichost", ".zip"], binmode: true)
+
+        Zip::OutputStream.open(temp) do |zip|
+          Dir.glob("#{path}/**/*").each do |file|
+            next unless File.file?(file)
+
+            relative_path = file.delete_prefix("#{path}/")
+            zip.put_next_entry(relative_path)
+            zip.write(File.read(file))
+          end
+        end
+
+        temp.rewind
+        temp
+      end
+
+      def upload(zipped_file)
+        uri = URI("https://builder.statichost.eu/#{@configuration.site_name}/drop")
+
+        request = Net::HTTP::Post.new(uri)
+        request["Authorization"] = "Bearer #{@configuration.api_key}"
+        request["Content-Type"] = "application/zip"
+        request["Accept"] = "application/json"
+        request.body = zipped_file.read
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(request)
+        end
+
+        case response.code.to_i
+        when 200..299
+          response.body.empty? ? {} : JSON.parse(response.body)
+        else
+          raise DeploymentError, "Statichost API error: #{response.code} #{response.body}"
+        end
+      end
+    end
+  end
+end

data/lib/beam_up/providers/transporter.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module BeamUp
+  module Providers
+    class Transporter < Base
+      class Config
+        def self.config_keys = %w[target_directory]
+
+        attr_accessor :target_directory
+
+        def with(options)
+          self.target_directory = options[:target_directory]
+          self
+        end
+
+        def validate!
+          raise ConfigurationError, "Target directory must be set" unless target_directory
+        end
+      end
+
+      def deploy!(path)
+        @path = path
+        files = files_to_deploy
+
+        puts "Energizing… 🚀"
+        puts "Matter stream detected: #{files.length} files"
+
+        FileUtils.mkdir_p(@configuration.target_directory)
+
+        files.each do |file|
+          relative_path = file.sub("#{@path}/", "")
+          target_path = File.join(@configuration.target_directory, relative_path)
+
+          FileUtils.mkdir_p(File.dirname(target_path))
+          FileUtils.cp(file, target_path)
+
+          puts "  Beaming: #{relative_path}"
+        end
+
+        puts "Transport complete. Files materialized at: #{@configuration.target_directory}"
+
+        Result.new(
+          provider: "Transporter",
+          deploy_id: files.length.to_s,
+          url: @configuration.target_directory
+        )
+      rescue => error
+        Result.new(provider: "Transporter", error: error.message)
+      end
+    end
+  end
+end

data/lib/beam_up/providers.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "beam_up/providers/base"
+require "beam_up/providers/aws_s3"
+require "beam_up/providers/bunny"
+require "beam_up/providers/digital_ocean_spaces"
+require "beam_up/providers/hetzner"
+require "beam_up/providers/neocities"
+require "beam_up/providers/netlify"
+require "beam_up/providers/sftp"
+require "beam_up/providers/statichost"
+require "beam_up/providers/transporter"
+
+module BeamUp
+  module Providers
+  end
+end

data/lib/beam_up/result.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module BeamUp
+  class Result
+    attr_reader :deploy_id, :error, :provider
+
+    def initialize(provider:, deploy_id: nil, url: nil, error: nil)
+      @provider = provider
+      @deploy_id = deploy_id
+      @url = url
+      @error = error
+    end
+
+    def success? = @error.nil?
+
+    def failure? = !success?
+
+    def message
+      if success?
+        "Successfully deployed to #{@provider}#{" at #{@url}" if @url}"
+      else
+        "Deployment to #{@provider} failed: #{@error}"
+      end
+    end
+  end
+end

data/lib/beam_up/version.rb

@@ -0,0 +1,3 @@
+module BeamUp
+  VERSION = "0.5.0"
+end

data/lib/beam_up.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "beam_up/version"
+require "beam_up/errors"
+require "beam_up/providers"
+require "beam_up/configuration"
+require "beam_up/result"
+require "beam_up/core"
+require "beam_up/cli"
+
+module BeamUp
+  PROVIDERS = {
+    "aws_s3" => Providers::AwsS3,
+    "bunny" => Providers::Bunny,
+    "digital_ocean_spaces" => Providers::DigitalOceanSpaces,
+    "hetzner" => Providers::Hetzner,
+    "neocities" => Providers::Neocities,
+    "netlify" => Providers::Netlify,
+    "sftp" => Providers::SFTP,
+    "statichost" => Providers::Statichost,
+    "transporter" => Providers::Transporter
+  }
+
+  class << self
+    def configure(&block) = Core.configure(&block)
+
+    def configuration = Core.configuration
+
+    def deploy!(path = nil, provider: nil, to: nil) = Core.deploy!(path, provider: (to || provider)&.to_s)
+  end
+end