buckler 1.0.0

data/lib/buckler/heroku.rb

@@ -0,0 +1,41 @@
+module Buckler
+
+  # Returns the Ruby executable on the user’s $PATH
+  def self.ruby_cmd
+    @ruby_cmd ||= find_executable0("ruby")
+  end
+
+  # Returns the Heroku executable on the user’s $PATH
+  def self.heroku_cmd
+    @heroku_cmd ||= find_executable0("heroku")
+  end
+
+  # True if the user has a Heroku and Ruby executable
+  def self.heroku_available?
+    ruby_cmd.present? && heroku_cmd.present?
+  end
+
+  # Fetches the given environment `variable_name` from the user’s Heroku project
+  def self.heroku_config_get(variable_name)
+
+    command_output, command_intake = IO.pipe
+
+    pid = Kernel.spawn(
+      "#{ruby_cmd} #{heroku_cmd} config:get #{variable_name}",
+      STDOUT => command_intake,
+      STDERR => command_intake
+    )
+
+    command_intake.close
+
+    _, status = Process.wait2(pid)
+
+    if status.exitstatus == 0
+      return command_output.read.to_s
+    else
+      return false
+    end
+
+  end
+
+end

data/lib/buckler/logging.rb

@@ -0,0 +1,19 @@
+module Buckler::Logging
+
+  def log(message)
+    STDOUT.print("#{message}\n")
+  end
+
+  def alert(message)
+    STDERR.print("#{message.dangerize}\n")
+  end
+
+  def verbose(message)
+    STDERR.print("#{message}\n") if $buckler_verbose_mode
+  end
+
+end
+
+module Buckler
+  extend Buckler::Logging
+end

data/lib/buckler/monkey_patches.rb

@@ -0,0 +1,19 @@
+# When you call MakeMakefile methods, they write information to ./mkmf.conf.
+# Please don’t do that, MakeMakefile.
+module MakeMakefile::Logging
+  @logfile = File::NULL
+end
+
+# The Aws gem complains on STDOUT when you’re redirected to the right region.
+# Silence warnings about region redirects, they’re unavoidable with this tool.
+module Aws
+  module Plugins
+    class S3RequestSigner < Seahorse::Client::Plugin
+      class BucketRegionErrorHandler < Handler
+        def log_warning(*args)
+          # Intentional no-op
+        end
+      end
+    end
+  end
+end

data/lib/buckler/regions.rb

@@ -0,0 +1,23 @@
+module Buckler
+
+  S3_BUCKET_REGIONS = {
+    "us-east-1"      => "🇺🇸  US East (Virginia)",
+    "us-west-1"      => "🇺🇸  US West (California)",
+    "us-west-2"      => "🇺🇸  US West (Oregon)",
+    "sa-east-1"      => "🇧🇷  South America (São Paulo)",
+    "eu-central-1"   => "🇩🇪  Europe (Frankfurt)",
+    "eu-west-1"      => "🇮🇪  Europe (Ireland)",
+    "ap-northeast-1" => "🇯🇵  Asia Pacific (Tokyo)",
+    "ap-northeast-2" => "🇰🇷  Asia Pacific (Seoul)",
+    "ap-south-1"     => "🇮🇳  Asia Pacific (Mumbai)",
+    "ap-southeast-1" => "🇸🇬  Asia Pacific (Singapore)",
+    "ap-southeast-2" => "🇦🇺  Asia Pacific (Sydney)",
+    "cn-north-1"     => "🇨🇳  China (Beijing)",
+  }.freeze
+
+  # True if the given name is a valid AWS region.
+  def self.valid_region?(name)
+    S3_BUCKET_REGIONS.keys.include?(name)
+  end
+
+end

data/lib/buckler/strings.rb

@@ -0,0 +1,24 @@
+class String
+
+  # Returns a copy of this string with terminal escapes to bold it
+  def bold
+    "\033[1m#{self}\e[0m"
+  end
+
+  # Returns a copy of this string with terminal escapes to make it red
+  def dangerize
+    "\e[38;5;196m#{self}\e[0m"
+  end
+
+  # Returns a copy of this string with terminal escapes to make it a color
+  # Options: `:orange` or `:pink`
+  def bucketize(color = :orange)
+    case color
+    when :pink
+      "\e[38;5;206m#{self}\e[0m"
+    else
+      "\e[38;5;208m#{self}\e[0m"
+    end
+  end
+
+end

data/lib/buckler/thread_dispatch.rb

@@ -0,0 +1,48 @@
+module Buckler
+  class ThreadDispatch
+
+    include Buckler::Logging
+
+    def initialize
+      @lambda_pool = []
+      @thread_pool = []
+      @max_threads = Etc.nprocessors * 2 # Twice the number of CPU cores available to Ruby
+    end
+
+    def queue(λ)
+      @lambda_pool << λ
+    end
+
+    def any_running_threads?
+      @thread_pool.any?{|s| s.status == "run"}
+    end
+
+    def running_thread_count
+      @thread_pool.select{|s| s.status == "run"}.count
+    end
+
+    def perform_and_wait
+
+      Thread.abort_on_exception = true
+
+      start_time = Time.now
+
+      @lambda_pool.each do |λ|
+        while running_thread_count >= @max_threads
+          verbose "Sleeping due to worker limit. #{running_thread_count} currently running."
+          sleep 0.2
+        end
+        @thread_pool << Thread.new(&λ)
+      end
+
+      verbose "All workers spawned, waiting for workers to finish"
+      while any_running_threads? do
+        sleep 0.2
+      end
+
+      return (Time.now - start_time).round(2)
+
+    end
+
+  end
+end

data/lib/buckler/version.rb

@@ -0,0 +1,14 @@
+module Buckler
+
+  # Returns Buckler’s version number
+  def self.version
+    Gem::Version.new("1.0.0")
+  end
+
+  # Contains Buckler’s version number
+  module VERSION
+    MAJOR, MINOR, TINY, PRE = Buckler.version.segments
+    STRING = Buckler.version.to_s
+  end
+
+end

data/test/buckler_test.rb

@@ -0,0 +1,80 @@
+class BucklerTest < Minitest::Test
+
+  # An S3 client for checking/cleaning the results of actions
+  # that the bucket executable should have performed
+
+  def initialize(*args)
+    @s3 = Aws::S3::Client.new(
+      region: "us-east-1",
+      access_key_id: ENV.fetch("AWS_ACCESS_KEY_ID"),
+      secret_access_key: ENV.fetch("AWS_SECRET_ACCESS_KEY"),
+    )
+    super
+  end
+
+  # Create a test bucket and return it
+
+  def create_test_bucket
+    test_name = "buckler-#{SecureRandom.hex(6)}"
+    bucket = Aws::S3::Bucket.new(test_name, client:@s3)
+    bucket.create
+    bucket.wait_until_exists
+    return [bucket, test_name]
+  end
+
+  # Fills a bucket with random, but testable objects
+  
+  def load_bucket_with_objects(bucket)
+    50.times do
+      bucket.put_object({
+        acl: "private",
+        body: SecureRandom.hex,
+        key: "#{SecureRandom.uuid}.txt",
+        content_type: "text/plain",
+        cache_control: "no-cache",
+      })
+    end
+    fail unless bucket.objects.to_a.many?
+    return true
+  end
+
+  # Runs the given buckler `command`
+  # Returns two values: the text that the process printed to STDOUT
+  # and the text the process printed to STDERR
+
+  def run_buckler_command(command)
+
+    command_stdout_ouput, command_stdout_intake = IO.pipe
+    command_stderr_ouput, command_stderr_intake = IO.pipe
+
+    environment = {
+      "AWS_ACCESS_KEY_ID" => ENV.fetch("AWS_ACCESS_KEY_ID"),
+      "AWS_SECRET_ACCESS_KEY" => ENV.fetch("AWS_SECRET_ACCESS_KEY"),
+    }
+
+    pid = Kernel.spawn(
+      environment,
+      "#{BUCKLER_EXECUTABLE} #{command}",
+      STDOUT => command_stdout_intake,
+      STDERR => command_stderr_intake,
+    )
+
+    command_stdout_intake.close
+    command_stderr_intake.close
+
+    Process.wait2(pid)
+
+    stdout_results = command_stdout_ouput.read
+    stderr_results = command_stderr_ouput.read
+
+    command_stdout_ouput.close
+    command_stderr_ouput.close
+
+    return [
+      stdout_results,
+      stderr_results
+    ]
+
+  end
+
+end

data/test/integration/bad_options_test.rb

@@ -0,0 +1,25 @@
+class BadOptionsTest < BucklerTest
+
+  def test_bad_credentials
+
+    # Errors about bad credentials
+    stdout, stderr = run_buckler_command("list --id CUTE_CATS --secret BUT_ALSO_DOGGIES")
+    assert stderr.include?("Invalid AWS Access Key"), "Error message should be printed"
+    assert stderr.include?("CUTE_CATS"), "Should repeat Key ID"
+
+    # Errors when the ID is correct but the secret is wrong
+    stdout, stderr = run_buckler_command("list --id #{ENV.fetch("AWS_ACCESS_KEY_ID")} --secret BUT_ALSO_DOGGIES")
+    assert stderr.include?("Invalid AWS Secret Access Key"), "Error mesage should be printed"
+    assert stderr.include?(ENV.fetch("AWS_ACCESS_KEY_ID")), "Should repeat Key ID"
+
+  end
+
+  def test_invaid_options
+
+    # Passing invalid options should not work
+    stdout, stderr = run_buckler_command("list --fake FAKE --uhh")
+    assert stderr.include?("illegal option"), "Error message should be printed"
+
+  end
+
+end

data/test/integration/create_bucket_test.rb

@@ -0,0 +1,27 @@
+class CreateBucketTest < BucklerTest
+
+  def test_create_bucket
+
+    test_name = "buckler-#{SecureRandom.hex(6)}"
+    bucket = Aws::S3::Bucket.new(test_name, client:@s3)
+
+    # Test that a bucket was indeed created
+
+    stdout, stderr = run_buckler_command("create #{test_name}")
+    assert stdout.include?("available for use"), "“availble for use” text should be printed"
+    assert stdout.include?(test_name), "Bucket name should be repeated to user"
+    assert bucket.exists?, "Bucket should be created"
+
+    # Can’t create a bucket that already exisits
+
+    stdout, stderr = run_buckler_command("create #{test_name}")
+    assert stderr.include?("already exists"), "“already exists” text not printed"
+    assert stderr.include?(test_name), "Bucket name not repeated to user"
+
+    # Cleanup
+
+    bucket.delete! if bucket.exists?
+
+  end
+
+end

data/test/integration/destroy_bucket_test.rb

@@ -0,0 +1,21 @@
+class DestroyBucketTest < BucklerTest
+
+  def test_destroy_bucket
+
+    bucket, test_name = create_test_bucket
+
+    # Test that a bucket was indeed destroyed
+
+    stdout, stderr = run_buckler_command("destroy #{test_name} --confirm #{test_name}")
+    assert stdout.include?("destroyed"), "Destruction confirmation should be printed"
+    assert stdout.include?(test_name), "Bucket name should be repeated"
+
+    # Can’t destroy a bucket that doesn’t exist
+
+    stdout, stderr = run_buckler_command("destroy #{test_name}")
+    assert stderr.include?("No such bucket"), "Rejection message should be printed"
+    assert stderr.include?(test_name), "Bucket name should be repeated to user"
+
+  end
+
+end

data/test/integration/empty_bucket_test.rb

@@ -0,0 +1,25 @@
+class EmptyBucketTest < BucklerTest
+
+  def test_empty_bucket
+
+    # Fill a bucket and empty it
+
+    bucket, test_name = create_test_bucket
+    load_bucket_with_objects(bucket)
+    stdout, stderr = run_buckler_command("empty #{test_name} --confirm #{test_name}")
+    assert bucket.objects.none?, "The bucket should be emptied"
+
+    # Can’t empty a non-existant bucket
+
+    test_name = "buckler-#{SecureRandom.hex(6)}"
+    stdout, stderr = run_buckler_command("empty #{test_name}")
+    assert stderr.include?("No such"), "Error message should be printed"
+    assert stderr.include?(test_name), "Bucket name should be repeated"
+
+    # Cleanup
+
+    bucket.delete! if bucket.exists?
+
+  end
+
+end

data/test/integration/list_buckets_test.rb

@@ -0,0 +1,20 @@
+class ListBucketsTest < BucklerTest
+
+  def test_list_buckets
+
+    bucket, test_name = create_test_bucket
+
+    # Test that a bucket is listed
+
+    stdout, stderr = run_buckler_command("list")
+    assert stdout.include?(test_name), "Bucket name should be repeated"
+    assert stdout.include?("us-east-1"), "Bucket region should be repeated"
+    assert stdout.include?("NAME"), "Header should be printed"
+
+    # Cleanup
+
+    bucket.delete! if bucket.exists?
+
+  end
+
+end

data/test/integration/list_regions_test.rb

@@ -0,0 +1,15 @@
+class ListRegionsTest < BucklerTest
+
+  def test_list_regions
+
+    stdout, stderr = run_buckler_command("regions")
+    assert stdout.include?("REGION"), "Header should be printed"
+    assert stdout.include?("us-west-1"), "Other rows should be printed"
+    assert stdout.include?("eu-central-1"), "Other rows should be printed"
+    assert stdout.include?("🇰🇷"), "Other rows should be printed"
+    assert stdout.include?("China"), "Other rows should be printed"
+    assert stdout.include?("Tokyo"), "Other rows should be printed"
+
+  end
+
+end

data/test/integration/sync_buckets_test.rb

@@ -0,0 +1,30 @@
+class SyncBucketsTest < BucklerTest
+
+  def test_sync_buckets
+
+    # Fill a bucket and sync it
+
+    source_bucket, source_name = create_test_bucket
+    target_bucket, target_name = create_test_bucket
+    load_bucket_with_objects(source_bucket)
+
+    stdout, stderr = run_buckler_command("sync #{source_name} #{target_name} --confirm #{target_name}")
+    assert target_bucket.objects.to_a.many?, "The target bucket should be filled with goodies"
+    assert target_bucket.objects.first.object.content_type.include?("text/plain"), "Content-Type headers should have synced"
+    assert target_bucket.objects.first.object.cache_control.include?("no-cache"), "Cache-Control headers should have synced"
+
+    # Can’t sync bad buckets
+
+    bad_name = "bucker-#{SecureRandom.hex(6)}"
+    stdout, stderr = run_buckler_command("sync #{source_name} #{bad_name} --confirm #{bad_name}")
+    assert stderr.include?("No such bucket"), "“No such” message should be printed"
+    assert stderr.include?(bad_name), "Bucket name should be repeated"
+
+    # Cleanup
+
+    source_bucket.delete! if source_bucket.exists?
+    target_bucket.delete! if target_bucket.exists?
+
+  end
+
+end