exercism-config 0.33.0

data/README.md

@@ -0,0 +1,26 @@
+# Exercism Config
+
+![Tests](https://github.com/exercism/config/workflows/Tests/badge.svg)
+[![Maintainability](https://api.codeclimate.com/v1/badges/513edbd6599a2de3218d/maintainability)](https://codeclimate.com/github/exercism/config/maintainability)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/513edbd6599a2de3218d/test_coverage)](https://codeclimate.com/github/exercism/config/test_coverage)
+[![Gem Version](https://badge.fury.io/rb/exercism_config.svg)](https://badge.fury.io/rb/exercism_config)
+
+When terraform creates Exercism's infrastructure, it writes endpoints and DNS entries to DynamoDB.
+This gem allows you to trivially retrieve that data.
+
+When running on AWS, simply ensure the machine has read-access to the relevant table (currently hardcoded to `config`).
+On a local machine specify the AWS_PROFILE environment variable with the relevant profile stored in your `.aws/credentials`.
+
+## Usage
+
+Simply include this gem in your Gemfile, require it, and then refer to the object:
+
+```ruby
+# Gemfile
+gem 'exercism_config'
+
+# Your code
+require 'exercism_config'
+ExercismConfig.config.webservers_alb_dns_name
+```
+

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task default: :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'exercism_config'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/release

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+gem bump -c -v minor -t -p -r

data/bin/rubocop-quick

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+git diff --name-status --staged | grep '^[MA]' | grep -o '\\s\\+.*rb' | xargs bundle exec rubocop --except Metrics --auto-correct --format quiet --force-exclusion lib/exercism_config.rb && \
+git diff --name-status --staged | grep '^[MA]' | grep -o '\\s\\+.*rb' | xargs git add

data/bin/setup_exercism_config

@@ -0,0 +1,84 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'exercism_config'
+require 'erb'
+require 'yaml'
+
+env = ExercismConfig::DetermineEnvironment.call
+if env == :production
+  puts 'Aborted! This script should not be run in production.'
+  exit
+end
+
+def create_table(client)
+  client.create_table(
+    table_name: :config,
+    attribute_definitions: [
+      {
+        attribute_name: 'id',
+        attribute_type: 'S'
+      }
+    ],
+    key_schema: [
+      {
+        attribute_name: 'id',
+        key_type: 'HASH'
+      }
+    ],
+    provisioned_throughput: {
+      read_capacity_units: 1,
+      write_capacity_units: 1
+    }
+  )
+end
+
+def delete_table(client)
+  client.delete_table(
+    table_name: :config
+  )
+end
+
+def set_config_value(client, id, value)
+  client.put_item(
+    table_name: :config,
+    item: {
+      id: id,
+      value: value
+    }
+  )
+end
+
+client = ExercismConfig::SetupDynamoDBClient.call
+
+begin
+  create_table(client)
+rescue Aws::DynamoDB::Errors::ResourceInUseException => e
+  if ARGV.include?('--force')
+    puts 'Table exists. Recreating...'
+    delete_table(client)
+    create_table(client)
+    puts 'Table recreated.'
+  else
+    puts 'Table exists. Not recreating.'
+  end
+end
+
+settings_file_arg = ARGV.select { |arg| arg.start_with?('--settings-file=') }.first
+settings_file =
+  if settings_file_arg
+    settings_file_arg.split('=').last
+  elsif ENV['EXERCISM_DOCKER']
+    File.expand_path('../settings/docker.yml', __dir__)
+  elsif ENV['EXERCISM_CI']
+    File.expand_path('../settings/test-ci.yml', __dir__)
+  else
+    File.expand_path('../settings/development.yml', __dir__)
+  end
+
+puts "Using settings file: #{settings_file}"
+settings = YAML.load(ERB.new(File.read(settings_file)).result)
+
+settings.each do |key, value|
+  set_config_value(client, key, value)
+end

data/bin/setup_exercism_local_aws

@@ -0,0 +1,97 @@
+#!/usr/bin/env ruby
+require "bundler/setup"
+require "exercism_config"
+
+# Only allow this to run in development
+return unless Exercism.environment == :development
+
+puts "Create AWS/DynamoDB tables..."
+
+Exercism.config.dynamodb_client = ExercismConfig::SetupDynamoDBClient.()
+
+##################
+# Setup local s3 #
+##################
+
+# We don't need this running for CI atm as none of our
+# tests actually hit s3. Although we might choose to change this
+unless ENV["EXERCISM_CI"]
+  begin
+    ExercismConfig::SetupS3Client.().create_bucket(bucket: Exercism.config.aws_iterations_bucket)
+  rescue Seahorse::Client::NetworkingError => e
+    puts "local S3 not up yet..."
+    sleep 2 # slighty retry delaty
+    retry
+  end
+end
+
+########################
+# Setup local dynamodb #
+########################
+%w[tooling_jobs tooling_jobs-test].each do |table_name|
+  begin
+    Exercism.config.dynamodb_client.delete_table(
+      table_name: table_name
+    )
+  rescue Aws::DynamoDB::Errors::ResourceNotFoundException
+  end
+  puts "[x] #{table_name}"
+
+  Exercism.config.dynamodb_client.create_table(
+    table_name: table_name,
+    attribute_definitions: [
+      {
+        attribute_name: "id",
+        attribute_type: "S"
+      }
+    ],
+    key_schema: [
+      {
+        attribute_name: "id",
+        key_type: "HASH"
+      }
+    ],
+    provisioned_throughput: {
+      read_capacity_units: 1,
+      write_capacity_units: 1
+    }
+  )
+
+  Exercism.config.dynamodb_client.update_table(
+    table_name: table_name,
+    attribute_definitions: [
+      {
+        attribute_name: "job_status",
+        attribute_type: "S"
+      },
+      {
+        attribute_name: "created_at",
+        attribute_type: "N"
+      }
+    ],
+    global_secondary_index_updates: [
+      {
+        create: {
+          index_name: "job_status", # required
+          key_schema: [ # required
+            {
+              attribute_name: "job_status", # required
+              key_type: "HASH" # required, accepts HASH, RANGE
+            },
+            {
+              attribute_name: "created_at", # required
+              key_type: "RANGE" # required, accepts HASH, RANGE
+            }
+          ],
+          projection: { # required
+            projection_type: "KEYS_ONLY"
+          },
+          provisioned_throughput: {
+            read_capacity_units: 1, # required
+            write_capacity_units: 1 # required
+          }
+        }
+      }
+    ]
+  )
+end

data/exercism_config.gemspec

@@ -0,0 +1,41 @@
+require_relative 'lib/exercism_config/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'exercism-config'
+  spec.version       = ExercismConfig::VERSION
+  spec.authors       = ['Jeremy Walker']
+  spec.email         = ['jez.walker@gmail.com']
+
+  spec.summary       = 'Retrieves stored config for Exercism'
+  spec.homepage      = 'https://exercism.io'
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.3.0')
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/exercism/config'
+
+  # 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(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "bin"
+  spec.executables   = %w[
+    setup_exercism_config
+    setup_exercism_local_aws
+  ]
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'aws-sdk-dynamodb', '~> 1.0'
+  spec.add_dependency 'mandate'
+  spec.add_dependency 'zeitwerk'
+
+  spec.add_development_dependency 'bundler', '~> 2.1'
+  spec.add_development_dependency 'minitest', '~> 5.0'
+  spec.add_development_dependency 'mocha'
+  spec.add_development_dependency 'rake', '~> 12.3'
+
+  # This isn't a compulsary dependency
+  # but can be used if someone puts it in their
+  # own gemfile
+  spec.add_development_dependency 'aws-sdk-s3'
+end

data/lib/exercism/config.rb

@@ -0,0 +1,12 @@
+module Exercism
+  class Config < OpenStruct
+    def initialize(data, aws_settings)
+      super(data)
+      self.aws_settings = aws_settings
+    end
+
+    def to_json(*_args)
+      to_h.to_json
+    end
+  end
+end

data/lib/exercism_config.rb

@@ -0,0 +1,27 @@
+require 'aws-sdk-dynamodb'
+require 'mandate'
+require 'ostruct'
+require 'json'
+
+require_relative 'exercism_config/determine_environment'
+require_relative 'exercism_config/generate_aws_settings'
+require_relative 'exercism_config/setup_dynamodb_client'
+require_relative 'exercism_config/setup_s3_client'
+require_relative 'exercism_config/retrieve'
+require_relative 'exercism_config/generate_aws_settings'
+require_relative 'exercism_config/version'
+
+require_relative 'exercism/config'
+
+module Exercism
+  class ConfigError < RuntimeError
+  end
+
+  def self.environment
+    @environment ||= ExercismConfig::DetermineEnvironment.()
+  end
+
+  def self.config
+    @config ||= ExercismConfig::Retrieve.()
+  end
+end

data/lib/exercism_config/determine_environment.rb

@@ -0,0 +1,16 @@
+module ExercismConfig
+  class DetermineEnvironment
+    include Mandate
+
+    def call
+      env = ENV['EXERCISM_ENV'] || ENV['RAILS_ENV'] || ENV['APP_ENV']
+      raise Exercism::ConfigError, 'No environment set - set one of EXERCISM_ENV, RAILS_ENV or APP_ENV' unless env
+
+      unless %w[development test production].include?(env)
+        raise Exercism::ConfigError, "environment must be one of development, test or production. Got #{env}."
+      end
+
+      env.to_sym
+    end
+  end
+end

data/lib/exercism_config/generate_aws_settings.rb

@@ -0,0 +1,38 @@
+module ExercismConfig
+  class GenerateAwsSettings
+    include Mandate
+
+    def call
+      {
+        region: 'eu-west-2',
+        profile: profile,
+        access_key_id: aws_access_key_id,
+        secret_access_key: aws_secret_access_key
+      }.select { |_k, v| v }
+    end
+
+    memoize
+    def aws_access_key_id
+      case Exercism.environment
+      when :development, :test
+        'FAKE'
+      end
+    end
+
+    memoize
+    def aws_secret_access_key
+      case Exercism.environment
+      when :development, :test
+        'FAKE'
+      end
+    end
+
+    memoize
+    def profile
+      case Exercism.environment
+      when :production
+        'exercism_staging'
+      end
+    end
+  end
+end

data/lib/exercism_config/retrieve.rb

@@ -0,0 +1,67 @@
+module ExercismConfig
+  class Retrieve
+    include Mandate
+
+    def call
+      return generate_mock if Exercism.environment == :test
+
+      retrieve_from_dynamodb
+    end
+
+    private
+    def generate_mock
+      require 'erb'
+      require 'yaml'
+
+      filename = if ENV["EXERCISM_CI"]
+                   'test-ci'
+                 elsif ENV["EXERCISM_DOCKER"]
+                   'test-docker'
+                 else
+                   'test-local'
+                 end
+
+      settings_file = File.expand_path("../../../settings/#{filename}.yml", __FILE__)
+      settings = YAML.safe_load(ERB.new(File.read(settings_file)).result)
+
+      Exercism::Config.new(settings, {})
+    end
+
+    def retrieve_from_dynamodb
+      client = SetupDynamoDBClient.()
+
+      resp = client.scan({ table_name: 'config' })
+      items = resp.to_h[:items]
+      data = items.each_with_object({}) do |item, h|
+        h[item['id']] = item['value']
+      end
+
+      # Tweak things for dynamodb when we're running in test mode
+      if Exercism.environment == :test
+        %w[dynamodb_tooling_jobs_table].each do |key|
+          data[key] = "#{data[key]}-test"
+        end
+      end
+
+      aws_settings = GenerateAwsSettings.()
+      Exercism::Config.new(data, aws_settings)
+    rescue Exercism::ConfigError
+      raise
+    rescue StandardError => e
+      raise Exercism::ConfigError, "Exercism Config could not be loaded: #{e.message}"
+    end
+
+    memoize
+    def aws_client
+      config = {
+        region: 'eu-west-2',
+        profile: profile,
+        endpoint: endpoint,
+        access_key_id: aws_access_key_id,
+        secret_access_key: aws_secret_access_key
+      }.select { |_k, v| v }
+
+      Aws::DynamoDB::Client.new(config)
+    end
+  end
+end