parity_logandsprice 3.4.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5fe0758511222cfb3bedfad544400e1eadc25052cd838738ac13df827db8d5e1
+  data.tar.gz: 6b3fa0cd17b949d9ffa022269130be777776e6c50d31ab32707762094be405f6
+SHA512:
+  metadata.gz: 9f78ca7854a340b404e862d127c8ff2f588d6ea93d59262d2d1a89fbb32e994423b1e0683cd94601dc15b2cfb49256aa8226c7983e09ce9fc0e75f287ea9d211
+  data.tar.gz: bab0ce042de415c8fed0eb2adc3e16be9204ab4bc1216469779d17fd87b404056e89b561c2978f3f8216e13def603ba38f38645b57e52f42c1f805418e0ddbb8

data/README.md

@@ -0,0 +1,198 @@
+Parity
+======
+
+[![Reviewed by Hound](https://img.shields.io/badge/Reviewed_by-Hound-8E64B0.svg)](https://houndci.com)
+
+Shell commands for development, staging, and production parity for Heroku apps.
+
+Install
+-------
+
+    gem install parity
+
+Or bundle it in your project:
+
+    gem "parity"
+
+[releases]: https://github.com/thoughtbot/parity/releases
+
+Parity requires these command-line programs:
+
+    git
+    heroku
+    pg_restore
+
+Usage
+-----
+
+Backup a database:
+
+    production backup
+    staging backup
+
+Restore a production or staging database backup into development:
+
+    development restore production
+    development restore staging
+
+Or, if `restore-from` reads better to you, it's the same thing:
+
+    development restore-from production
+    development restore-from staging
+
+ * Note that the `restore` command will use the most recent backup (from _staging_ or _production_). You may first need to create a more recent backup before restoring, to prevent download of a very old backup.
+
+Push your local development database backup up to staging:
+
+    staging restore development
+
+Deploy main to production (note that prior versions of Parity would run
+database migrations, that's now better handled using [Heroku release phase]):
+
+    production deploy
+
+[Heroku release phase]: https://devcenter.heroku.com/articles/release-phase
+
+Deploy the current branch to staging:
+
+    staging deploy
+
+_Note that deploys to non-production environments use `git push --force`._
+
+Open a console:
+
+    production console
+    staging console
+    pr_app 1234 console
+
+Migrate a database and restart the dynos:
+
+    production migrate
+    staging migrate
+    pr_app 1234 migrate
+
+Tail a log:
+
+    production tail
+    staging tail
+    pr_app 1234 tail
+
+The scripts also pass through, so you can do anything with them that you can do
+with `heroku ______ --remote staging` or `heroku ______ --remote production`:
+
+    watch production ps
+    staging open
+
+You can optionally parallelize a DB restore by passing `--parallelize`
+as a flag to the `development` or `production` commands:
+```
+    development restore-from production --parallelize
+```
+
+[2]: http://redis.io/commands
+
+Convention
+----------
+
+Parity expects:
+
+* A `staging` remote pointing to the staging Heroku app.
+* A `production` remote pointing to the production Heroku app.
+```
+heroku git:remote -r staging -a your-staging-app
+heroku git:remote -r production -a your-production-app
+```
+* There is a `config/database.yml` file that can be parsed as YAML for
+  `['development']['database']` or, alternatively, `['development']['primary']['database']` for multi-database configurations.
+
+Pipelines
+---------
+
+If you deploy review applications with Heroku pipelines, run commands against
+those applications with the `pr_app` command, followed by the PR number for your
+application:
+
+```
+pr_app 1234 console
+```
+
+This command assumes that your review applications have a name derived from the
+name of the application your `staging` Git remote points at.
+
+Customization
+-------------
+
+If you have Heroku environments beyond staging and production (such as a feature
+environment for each developer), you can add a [binstub] to the `bin` folder of
+your application. Custom environments share behavior with staging: they can be
+backed up and can restore from production.
+
+Using feature environments requires including Parity as a gem in your
+application's Gemfile.
+
+```ruby
+gem "parity"
+```
+
+[binstub]: https://github.com/sstephenson/rbenv/wiki/Understanding-binstubs
+
+Here's an example binstub for a 'feature-geoff' environment, hosted at
+myapp-feature-geoff.herokuapp.com.
+
+```ruby
+#!/usr/bin/env ruby
+
+require "parity"
+
+if ARGV.empty?
+  puts Parity::Usage.new
+else
+  Parity::Environment.new("feature-geoff", ARGV).run
+end
+```
+
+Issues
+------
+Please fill out our [issues template](.github/issue_template.md) if you are
+having problems.
+
+Contributing
+------------
+
+Please see [`CONTRIBUTING.md`](CONTRIBUTING.md) for details.
+
+Version History
+---------------
+
+Please see the [releases page](https://github.com/thoughtbot/parity/releases)
+for the version history, along with a description of the changes in each
+release.
+
+Releasing
+---------
+
+See guidelines in [`RELEASING.md`](RELEASING.md) for details
+
+License
+-------
+
+Parity is © 2013-2021 thoughtbot, inc.
+It is free software,
+and may be redistributed under the terms specified in the [LICENSE] file.
+
+[LICENSE]: LICENSE
+
+About thoughtbot
+----------------
+
+![thoughtbot](http://presskit.thoughtbot.com/images/thoughtbot-logo-for-readmes.svg)
+
+Parity is maintained and funded by thoughtbot, inc.
+The names and logos for thoughtbot are trademarks of thoughtbot, inc.
+
+We are passionate about open source software.
+See [our other projects][community].
+We are [available for hire][hire].
+
+[community]: https://thoughtbot.com/community?utm_source=github
+[hire]: https://thoughtbot.com?utm_source=github

data/bin/development

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path(File.join("..", "..", "lib"), __FILE__)
+require "parity"
+
+if ARGV.empty?
+  puts Parity::Usage.new
+else
+  exit Parity::Environment.new('development', ARGV).run
+end

data/bin/pr_app

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path(File.join("..", "..", "lib"), __FILE__)
+require "open3"
+require "parity"
+
+if ARGV.empty?
+  puts Parity::Usage.new
+else
+  review_app_number = ARGV.first
+  staging_git_remote = Open3.capture3("git remote get-url staging")[0].strip
+  review_app_prefix = staging_git_remote[/(?<=https:\/\/git\.heroku\.com\/|git@heroku\.com:)(.*)/].gsub(/-staging.git/, "")
+
+  puts "*"*60
+  puts "review_app_prefix: #{review_app_prefix}"
+  puts "review_app_number: #{review_app_number}"
+  puts "ARGV: #{ARGV}"
+  puts "*"*60
+  exit Parity::Environment.new(
+    "#{review_app_prefix}-pr-#{review_app_number}",
+    ARGV.drop(1),
+    app_argument: "--app",
+  ).run
+end

data/bin/production

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path(File.join("..", "..", "lib"), __FILE__)
+require "parity"
+
+if ARGV.empty?
+  puts Parity::Usage.new
+else
+  exit Parity::Environment.new('production', ARGV).run
+end

data/bin/staging

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path(File.join("..", "..", "lib"), __FILE__)
+require "parity"
+
+if ARGV.empty?
+  puts Parity::Usage.new
+else
+  exit Parity::Environment.new('staging', ARGV).run
+end

data/lib/parity/backup.rb

@@ -0,0 +1,147 @@
+require "etc"
+
+module Parity
+  class Backup
+    BLANK_ARGUMENTS = "".freeze
+    DATABASE_YML_RELATIVE_PATH = "config/database.yml".freeze
+    DEVELOPMENT_ENVIRONMENT_KEY_NAME = "development".freeze
+    PRIMARY_DATABASE_KEY_NAME = "primary".freeze
+    DATABASE_KEY_NAME = "database".freeze
+
+    def initialize(args)
+      puts "*"*60
+      puts args
+      puts "*"*60
+      @from, @to = args.values_at(:from, :to)
+      @additional_args = args[:additional_args] || BLANK_ARGUMENTS
+      @parallelize = args[:parallelize] || false
+      @app_argument = args[:app_argument]
+    end
+
+    def restore
+      if to == DEVELOPMENT_ENVIRONMENT_KEY_NAME
+        restore_to_development
+      elsif from == DEVELOPMENT_ENVIRONMENT_KEY_NAME
+        restore_from_development
+      else
+        restore_to_remote_environment
+      end
+    end
+
+    private
+
+    attr_reader :additional_args, :from, :to, :parallelize, :app_argument
+
+    alias :parallelize? :parallelize
+
+    def restore_from_development
+      reset_remote_database
+      Kernel.system(
+        "heroku pg:push #{development_db} DATABASE_URL #{app_argument} #{to} "\
+          "#{additional_args}",
+      )
+    end
+
+    def restore_to_development
+      ensure_temp_directory_exists
+      download_remote_backup
+      wipe_development_database
+      restore_from_local_temp_backup
+      delete_local_temp_backup
+      delete_rails_production_environment_settings
+    end
+
+    def wipe_development_database
+      Kernel.system(
+        "dropdb --if-exists #{development_db} && createdb #{development_db}",
+      )
+    end
+
+    def reset_remote_database
+      Kernel.system(
+        "heroku pg:reset #{app_argument} #{to} #{additional_args} "\
+          "--confirm #{heroku_app_name}",
+      )
+    end
+
+    def heroku_app_name
+      if app_argument == "--app"
+        to
+      else
+        HerokuAppName.new(to).to_s
+      end
+    end
+
+    def ensure_temp_directory_exists
+      Kernel.system("mkdir -p tmp")
+    end
+
+    def download_remote_backup
+      Kernel.system(
+        "curl -o tmp/latest.backup \"$(heroku pg:backups:url #{app_argument} #{from})\"",
+      )
+    end
+
+    def restore_from_local_temp_backup
+      Kernel.system(
+        "pg_restore tmp/latest.backup --verbose --no-acl --no-owner "\
+          "--dbname #{development_db} --jobs=#{processor_cores} "\
+          "#{additional_args}",
+      )
+    end
+
+    def delete_local_temp_backup
+      Kernel.system("rm tmp/latest.backup")
+    end
+
+    def delete_rails_production_environment_settings
+      Kernel.system(<<-SHELL)
+        psql #{development_db} -c "CREATE TABLE IF NOT EXISTS public.ar_internal_metadata (key character varying NOT NULL, value character varying, created_at timestamp without time zone NOT NULL, updated_at timestamp without time zone NOT NULL, CONSTRAINT ar_internal_metadata_pkey PRIMARY KEY (key)); UPDATE ar_internal_metadata SET value = 'development' WHERE key = 'environment'"
+      SHELL
+    end
+
+    def restore_to_remote_environment
+      reset_remote_database
+      Kernel.system(
+        "heroku pg:backups:restore #{backup_from} #{app_argument} #{to} "\
+          "#{additional_args}",
+      )
+    end
+
+    def backup_from
+      "`#{remote_db_backup_url}` DATABASE"
+    end
+
+    def remote_db_backup_url
+      "heroku pg:backups:url #{app_argument} #{from}"
+    end
+
+    def development_db
+      db_configuration = YAML.safe_load(database_yaml_file, aliases: true).
+        fetch(DEVELOPMENT_ENVIRONMENT_KEY_NAME)
+
+      if db_configuration.key?(PRIMARY_DATABASE_KEY_NAME)
+        db_configuration[PRIMARY_DATABASE_KEY_NAME].
+          fetch(DATABASE_KEY_NAME)
+      else
+        db_configuration.fetch(DATABASE_KEY_NAME)
+      end
+    end
+
+    def database_yaml_file
+      ERB.new(IO.read(DATABASE_YML_RELATIVE_PATH)).result
+    end
+
+    def processor_cores
+      if parallelize? && ruby_version_over_2_2?
+        Etc.nprocessors
+      else
+        1
+      end
+    end
+
+    def ruby_version_over_2_2?
+      Etc.respond_to?(:nprocessors)
+    end
+  end
+end

data/lib/parity/environment.rb

@@ -0,0 +1,147 @@
+require "parity/backup"
+
+module Parity
+  class Environment
+    def initialize(environment, subcommands, app_argument: "--remote")
+      self.environment = environment
+      self.subcommand = subcommands[0]
+      self.arguments = subcommands[1..-1]
+      self.app_argument = app_argument
+    end
+
+    def run
+      run_command || false
+    end
+
+    private
+
+    PROTECTED_ENVIRONMENTS = %w(development production)
+
+    attr_accessor :app_argument, :environment, :subcommand, :arguments
+
+    def run_command
+      if self.class.private_method_defined?(methodized_subcommand)
+        send(methodized_subcommand)
+      else
+        run_via_cli
+      end
+    end
+
+    def open
+      run_via_cli
+    end
+
+    def run_via_cli
+      Kernel.exec("heroku", subcommand, *arguments, app_argument, environment)
+    end
+
+    def backup
+      Kernel.system("heroku pg:backups:capture #{app_argument} #{environment}")
+    end
+
+    def deploy
+      if production?
+        Kernel.system("git push production #{branch_ref}")
+      else
+        Kernel.system(
+          "git push #{environment} HEAD:#{branch_ref} --force",
+        )
+      end
+    end
+
+    def branch_ref
+      main_ref_exists = system("git show-ref --verify --quiet refs/heads/main")
+      master_ref_exists = system(
+        "git show-ref --verify --quiet refs/heads/master",
+      )
+
+      if main_ref_exists && !master_ref_exists
+        "main"
+      else
+        "master"
+      end
+    end
+
+    def restore
+      if production? && !forced?
+        $stdout.puts "Parity does not support restoring backups into your "\
+          "production environment. Use `--force` to override."
+      else
+        Backup.new(
+          from: arguments.first,
+          to: environment,
+          parallelize: parallelize?,
+          additional_args: additional_restore_arguments,
+          app_argument: app_argument
+        ).restore
+      end
+    end
+
+    alias :restore_from :restore
+
+    def production?
+      environment == "production"
+    end
+
+    def forced?
+      arguments.include?("--force")
+    end
+
+    def parallelize?
+      arguments.include?("--parallelize")
+    end
+
+    def additional_restore_arguments
+      (arguments.drop(1) - ["--force", "--parallelize"] +
+        [restore_confirmation_argument]).compact.join(" ")
+    end
+
+    def restore_confirmation_argument
+      unless PROTECTED_ENVIRONMENTS.include?(environment) || from_development?
+        "--confirm #{app_argument == "--app" ? environment : heroku_app_name}"
+      end
+    end
+
+    def from_development?
+      arguments.first == "development"
+    end
+
+    def console
+      Kernel.system(
+        command_for_remote(
+          "run bundle exec rails console #{arguments.join(' ')}",
+        ),
+      )
+    end
+
+    def migrate
+      Kernel.system(%{
+        #{command_for_remote('run rake db:migrate')} &&
+        #{command_for_remote('restart')}
+      })
+    end
+
+    def tail
+      Kernel.system(
+        command_for_remote("logs --tail #{arguments.join(' ')}"),
+      )
+    end
+
+    def heroku_app_name
+      if app_argument == "--app"
+        environment
+      else
+        HerokuAppName.new(environment).to_s
+      end
+      
+    end
+
+    def command_for_remote(command)
+      "heroku #{command} #{app_argument} #{environment}"
+    end
+
+    def methodized_subcommand
+      subcommand.gsub("-", "_").to_sym
+    end
+  end
+end

data/lib/parity/heroku_app_name.rb

@@ -0,0 +1,18 @@
+module Parity
+  class HerokuAppName
+    def initialize(environment)
+      @environment = environment
+    end
+
+    def to_s
+      @heroku_app_name ||= Open3.
+        capture3("heroku info --remote #{environment}")[0].
+        split("\n")[0].
+        gsub(/(\s|=)+/, "")
+    end
+
+    private
+
+    attr_reader :environment
+  end
+end

data/lib/parity/usage.rb

@@ -0,0 +1,13 @@
+module Parity
+  class Usage
+    def to_s
+      File.read(readme).match(/Usage\n-----\n(.+)\nConvention\n------/m)[1]
+    end
+
+    private
+
+    def readme
+      File.join(File.dirname(__FILE__), '..', '..', 'README.md')
+    end
+  end
+end

data/lib/parity/version.rb

@@ -0,0 +1,3 @@
+module Parity
+  VERSION = "3.4.1".freeze
+end

data/lib/parity.rb

@@ -0,0 +1,11 @@
+$LOAD_PATH << File.expand_path("..", __FILE__)
+
+require "parity/heroku_app_name"
+require "parity/version"
+require "parity/environment"
+require "parity/usage"
+require "erb"
+require "open3"
+require "pathname"
+require "uri"
+require "yaml"

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: parity_logandsprice
+version: !ruby/object:Gem::Version
+  version: 3.4.1
+platform: ruby
+authors:
+- Dan Croak
+- Geoff Harcourt
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-11-10 00:00:00.000000000 Z
+dependencies: []
+description: |2
+      Development/staging/production parity makes it easier for
+      those who write the code to deploy the code.
+email:
+- logandsprice@gmail.com.com
+executables:
+- development
+- staging
+- production
+- pr_app
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/development
+- bin/pr_app
+- bin/production
+- bin/staging
+- lib/parity.rb
+- lib/parity/backup.rb
+- lib/parity/environment.rb
+- lib/parity/heroku_app_name.rb
+- lib/parity/usage.rb
+- lib/parity/version.rb
+homepage: https://github.com/logandsprice/parity
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key: 
+specification_version: 4
+summary: Shell commands for development, staging, and production parity.
+test_files: []