taperole 1.6.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cd21b5c1b7d9532c3a6225c43fc6225726196307
-  data.tar.gz: 1b30b5918731df5a64930e0fc7705ea9e05a53ca
+  metadata.gz: 21ca9a88b00c6e0ed2f77b29937b871038b3f911
+  data.tar.gz: 4768be3843152356b7add30fbe8e5e3dedfcaad2
 SHA512:
-  metadata.gz: accd791072ff897618d73a8a0d7b412feacdc3ab40740ddc5dd9939092ba1f7695d3f3cf5629fc6f61fca0848c061453d1499cec2262e0792799c1a92f937bf6
-  data.tar.gz: 8109633af31ad2bbc309aff92848c9c94f870048a1039eb2f9f33ce8ff481648d858b9c0e8886e114b75ce6d28a3fa6217ac19c7e88041bd1a6b6eca72a0b003
+  metadata.gz: e3c6f367b84e1b0b339fd4f768cf079e36279e3e35b310924de4d04836a4637a4706b4cb635bc1d09c895518a40f78ca04755250610b04618a2636531c117fd9
+  data.tar.gz: 5e1b9437c2ebfc85bdb591af65f4040ead65ec91977c7d3678c416ee86a1af4449fec373754284e33a580c0568a2e86a6b99c8a1f2790372e4cebacfd7c96a77

data/.travis.yml

@@ -6,5 +6,8 @@ services:
   - docker
 
 script:
+  - gem build taperole.gemspec
+  - gem install --dev taperole
+  - rake spec
   - docker build -f test/rails/Dockerfile -t imagetest .
   - docker run -i -t $(docker images -q imagetest) /start_rails.sh | grep "Hello"

data/CONTRIBUTING.md

@@ -5,6 +5,14 @@
 ###Workflow
 We use [Waffle.io](https://waffle.io/smashingboxes/tape) to manage our workflow for this project. Please respect the workflow and move PRs that are ready to be mereged into the 'Ready' column.
 
+####Testing
+
+There are two main ways we test taperole. The first is basic unit tests, via rspec. Those can be run via:
+
+`rake test`
+
+The second way is a kind of integration test. We use tape to stand up a basic vanilla rails app (leveraging docker) and then check that a curl returns the correct thing. There isn't an easy way to run this locally, but it is set up on travis to run automatically.
+
 ###PR Structure
 
 Please give details regarding your PR in the following format. It really helps with review and quickens the speed at which your changes are merged in

data/README.md

@@ -3,7 +3,7 @@
 # Infrastructure Management
 
 ## Deploying & provisioning with tape
-**Use Unbuntu trusty64 (14.04 x64)**
+**Use Unbuntu trusty64 (16 x64)**
 
 **Enable ssh access via root user**
 
@@ -45,9 +45,30 @@ All default configurations found in `vars/defaults.yml` can be overridden in you
 **Default Ruby Version** 2.3.0
 
 ### Backups
-Backups are handled via [duply](http://duply.net/) and occur every night at 4am under the root user. You can configure your backup schedule and target where you want your backups stored at within your `taperole/tape_vars.yml` file.
+Backups are handled via [duply](http://duply.net/) and are configured via the [Stouts.backup](https://github.com/Stouts/Stouts.backup) ansible galaxy role. Bacups occur every night at 4am under the root user. You can configure your backup schedule and target where you want your backups stored at within your `taperole/tape_vars.yml` file.
 
-By default, all servers in your [production] group will have backups enabled
+The default location for backups is the `/var/lib/postgresql/backups` directory.
+
+All servers in your [production] group will have backups enabled by default.
+
+Detailed configurations can be made in your tape_vars.yml file.
+
+```
+# Store Backups on S3
+backup_dir: s3+http://[aws_access_key:aws_secret_access_key]@bucket_name[/folder]
+
+# Store Backups on Seperate server via rsync
+backup_dir: s3+http://[aws_access_key:aws_secret_access_key]@bucket_name[/folder]
+
+# Adjust Cron Job Schedule (default is every night at 4am)
+backup_schedule: "* */4 * * *"
+
+# Change Which Servers are backed up
+backup_hosts:
+  - production
+  - staging
+  - qa
+```
 
 ### Custom roles
 You can add app specific ansible roles to `<app_root>/roles`.
@@ -93,7 +114,7 @@ localhost:2222 ansible_ssh_private_key_file=~/.vagrant.d/insecure_private_key
 The port number might be different if other vagrant machines are running, run `vagrant ssh-config`  to find the correct configuration.
 You can specify a port using the `ansible_ssh_port` in your hosts inventory file.
 
-3. Update `tape_vars.yml` with information to a [rails app you want to deploy](https://github.com/BrandonMathis/vanilla-rails-app)
+3. Update `tape_vars.yml` with information to a rails app you want to deploy
 4. `tape ansible everything -l vagrant`
 
 ### With Docker
@@ -235,6 +256,14 @@ This will git pull the latest changes from the tracking branch you specified and
 
 This command runs all Ansible roles specified in the deploy.yml playbook.
 
+### Rake tasks
+
+To run ad-hoc rake tasks, you can use the following:
+
+```
+tape ansible rake --task users:rank
+```
+
 ## Slack integration
 
 Tape includes built-in support for posting messages to slack at the beginning and end of deployments.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/Vagrantfile

@@ -2,25 +2,24 @@
 # vi: set ft=ruby :
 
 Vagrant.configure 2 do |config|
-  config.vm.box = 'ubuntu/trusty64'
+  config.vm.box = "ubuntu/xenial64"
 
-  name = %x[basename `git rev-parse --show-toplevel`].chomp
+  name = %x[basename `git rev-parse --show-toplevel`].chomp.gsub(/[^0-9a-z ]/i, '')
   config.vm.define "#{name}_vagrant_box"
+  config.vm.hostname = "#{name}"
 
-  # private_ip = "192.168.13.37"
-  # config.vm.network(:private_network, :ip => private_ip)
+  private_ip = "192.168.13.37"
+  config.vm.network(:private_network, :ip => private_ip)
 
-# TODO free me from the bonds of this ip
   config.vm.network 'forwarded_port', guest: 443, host: 8080
   config.vm.network 'private_network', type: 'dhcp'
 
-  config.ssh.insert_key = false
   config.ssh.shell = 'bash -c "BASH_ENV=/etc/profile exec bash"'
 
   config.vm.provision :shell, inline: <<-SCRIPT
     sudo su
     mkdir -p ~/.ssh/
-    cp /home/vagrant/.ssh/authorized_keys ~/.ssh/
+    cp /home/ubuntu/.ssh/authorized_keys ~/.ssh/
     chmod 600 ~/.ssh/authorized_keys
   SCRIPT
 end

data/bin/tape

@@ -1,92 +1,5 @@
 #!/usr/bin/env ruby
 
-$LOAD_PATH << File.join(__dir__, '..', 'lib')
+require 'taperole'
 
-require 'optparse'
-require 'ostruct'
-require 'tape'
-
-options = OpenStruct.new
-opt_parser = OptionParser.new do |opts|
-  opts.banner = "Usage: tape <module> <action> [options]"
-
-  opts.on("-v", "--[no-]verbose", "Be loud") {|v| options.verbose = v}
-  opts.on("--ask-vault-pass", "Ask for Ansible vault password") { options.vault = true }
-
-  opts.on("-i", "--inventory [INVENTORY_FILE]",
-    String, "Do actions with the given inventory file") do |i|
-      options.inventory_file = i
-    end
-
-  opts.on('-n', "--name [NAME]",
-    String, "The name of the machine to operate on") do |n|
-      options.name = n
-    end
-
-  opts.on('-p', "--port [PORT]",
-    Integer, "The port that the machine is listening on for SSH connections") do |p|
-      options.port = p
-    end
-
-  opts.on('-bBOOK', "--book=PLAYBOOK",
-    String, "A custom playbook to run") do |p|
-      options.book = p
-    end
-
-  opts.on("-h", "--help", "Show this help") do
-    STDERR.puts opts
-    exit 0
-  end
-
-  opts.on("-l", "--limit [PATTERN]",
-    String, "Limits ansible runs to hosts matching PATTERN") do |p|
-      options.host_pattern = p
-    end
-
-  opts.on("-t", "--tags [TAGS]",
-    String, "only run plays and tasks tagged with these values") do |t|
-      options.tags = t
-    end
-
-  opts.on("-r", "--role=ROLE_NAME",
-    String, "name of the role to operate on") do |r|
-      options.role = r
-    end
-
-  opts.separator ''
-  opts.separator "MODULES"
-  TapeBoxer.registered_modules.values.each do |exec_module|
-    opts.separator "  #{exec_module.name.to_s.upcase}"
-    exec_module.klass.actions.values.each do |action|
-      opts.separator "    #{action.name}: #{action.description}"
-    end
-  end
-end
-
-
-opt_parser.parse!(ARGV)
-
-fail_without = ->(&block){
-  val = block.call
-
-  if val
-    return val
-  else
-    STDERR.puts(opt_parser.help)
-    exit 1
-  end
-}
-
-module_name = fail_without.call{ ARGV.shift }.to_sym
-action_name = fail_without.call{ ARGV.shift }.to_sym
-
-exec_module = fail_without.call{TapeBoxer.registered_modules[module_name]}
-
-begin
-  exec_module.klass.new(options).execute_action(action_name)
-rescue TapeBoxer::InvalidAction,
-  TapeBoxer::ActionError, TapeBoxer::UnspecifiedOption => e
-
-  STDERR.puts(e.message)
-  exit 2
-end
+Taperole::Commands::Tape.start(ARGV)

data/lib/taperole/commands/ansible.rb

@@ -0,0 +1,56 @@
+module Taperole
+  module Commands
+    class Ansible < Thor
+      include Taperole::AnsibleRunner
+      include Taperole::Helpers::Logging
+
+      class_option :limit,
+                   type: :string,
+                   aliases: :l,
+                   desc: 'Limits ansible runs to hosts matching the given pattern'
+      class_option :task,
+                   type: :string,
+                   aliases: :T,
+                   desc: 'Name of the rake task to execute'
+      class_option :inventory,
+                   aliases: :i,
+                   type: :string,
+                   desc: 'Do actions with the given inventory file'
+      class_option :name,
+                   aliases: :n,
+                   type: :string,
+                   desc: 'The name of the machine to operate on'
+      class_option :port,
+                   aliases: :p,
+                   type: :numeric,
+                   desc: 'The port that the machine is listening on for SSH connections'
+      class_option :tags,
+                   aliases: :t,
+                   type: :string,
+                   desc: 'Only run plays and tasks tagged with these values'
+      class_option :role,
+                   aliases: :r,
+                   type: :string,
+                   desc: 'Name of the role to operate on'
+
+      class_option :'ask-vault-pass', type: :boolean, desc: 'Ask for Ansible vault password'
+
+      class_option :book,
+                   aliases: :b,
+                   type: :string,
+                   desc: 'A custom playbook to run'
+
+      desc 'everything', 'Initial setup of a server'
+      def everything
+        Taperole::Notifier.register_notifiers(options)
+        valid_preconfigs ? ansible(options: options) : puts("Not a Rails or JS app")
+      end
+
+      desc 'deploy', 'Deploy the latest version of the app'
+      def deploy
+        Taperole::Notifier.register_notifiers(options)
+        ansible_deploy(args: '-t be_deploy,fe_deploy', options: options)
+      end
+    end
+  end
+end

data/lib/taperole/commands/installer.rb

@@ -0,0 +1,19 @@
+module Taperole
+  module Commands
+    class Installer < Thor
+      include Taperole::Installer
+      include Taperole::Helpers::Logging
+
+      option :vagrant, type: :boolean
+      desc 'install', 'Creates all necessary hosts and config files'
+      def install
+        install_tape
+      end
+
+      desc 'uninstall', 'Cleans up files generated by the installer'
+      def uninstall
+        uninstall_tape
+      end
+    end
+  end
+end

data/lib/taperole/commands/tape.rb

@@ -0,0 +1,32 @@
+require 'thor'
+
+module Taperole
+  module Commands
+    class Tape < Thor
+      include Taperole::Helpers::Files
+      include Taperole::Helpers::Logging
+
+      class_option :verbose, type: :boolean
+      class_option :debug, type: :boolean
+      class_option :quiet, type: :boolean
+
+      map %w[--version -v] => :__print_version
+
+      desc "--version, -v", "print the version"
+      def __print_version
+        puts Taperole::VERSION
+      end
+
+      desc 'ansible [COMMAND]', 'run tapes ansible commands'
+      subcommand 'ansible', Ansible
+
+      desc 'installer [COMMAND]', 'install and uninstall tape'
+      subcommand 'installer', Installer
+
+      desc 'overwrite [ROLE]', 'Overwrite a taperole ansible role'
+      def overwrite_role(role)
+        FileUtils.cp_r("#{tape_dir}/roles/#{role}", "taperole/roles/")
+      end
+    end
+  end
+end

data/lib/taperole/core/ansible_runner.rb

@@ -0,0 +1,86 @@
+module Taperole
+  module AnsibleRunner
+    include Taperole::Helpers::Files
+
+    protected
+
+    def valid_preconfigs
+      if rails_app?
+        valid_gems
+      elsif fe_app?
+        true
+      else
+        false
+      end
+    end
+
+    def valid_gems
+      has_gem_in_gemfile?('unicorn')
+    end
+
+    def has_gem_in_gemfile?(name)
+      if open('Gemfile').grep(/#{name}/).empty?
+        logger.error "💥 ERROR: Add #{name} to your Gemfile!💥 ".red
+        false
+      else
+        true
+      end
+    end
+
+    def ansible(args: '', options: {})
+      exec_ansible("#{tapefiles_dir}/omnibox.yml", args, options)
+    end
+
+    def ansible_deploy(args: '', options: {})
+      exec_ansible("#{tapefiles_dir}/deploy.yml", args, options)
+    end
+
+    def ansible_custom_playbook(args: '', options: {})
+      exec_ansible("#{tapefiles_dir}/#{options[:book]}", args, options)
+    end
+
+    def ansible_rake_task(options: {})
+      exec_ansible("#{tapefiles_dir}/rake.yml", "--extra-vars \"task=#{options[:task]}\"", options)
+    end
+
+    def exec_ansible(playbook, args, options)
+      enforce_roles_path!
+      cmd = "ANSIBLE_CONFIG=#{local_dir}/.tape/ansible.cfg ansible-playbook -i"
+      cmd += " #{inventory_file(options)} #{playbook} #{args} #{hosts_flag(options)}"
+      cmd += " -e tape_dir=#{tape_dir}"
+      cmd += ' --ask-vault-pass' if options[:vault]
+      cmd += ' -vvvv' if options[:verbose]
+      cmd += " -t #{options[:tags]}" if options[:tags]
+      logger.info "Executing: #{cmd}" if options[:verbose]
+      Taperole::Notifier.notify_observers(:start)
+      if Kernel.system(cmd)
+        Taperole::Notifier.notify_observers(:success)
+      else
+        Taperole::Notifier.notify_observers(:fail)
+      end
+    end
+
+    def enforce_roles_path!
+      Dir.mkdir('.tape') unless Dir.exist?('.tape')
+
+      File.open("#{local_dir}/.tape/ansible.cfg", 'w') do |f|
+        f.puts '[defaults]'
+        f.puts "roles_path=.tape/roles:#{tape_dir}/roles:#{tape_dir}/vendor"
+        f.puts "inventory=#{tapefiles_dir}/hosts"
+        f.puts "retries-dir=/dev/null"
+        f.puts "retry_files_enabled = False"
+        f.puts '[ssh_connection]'
+        f.puts 'ssh_args=-o ForwardAgent=yes'
+      end
+    end
+
+    def hosts_flag(options)
+      limit = options[:limit]
+      "-l #{limit}" if limit
+    end
+
+    def inventory_file(options)
+      options[:inventory_file] || "#{tapefiles_dir}/hosts"
+    end
+  end
+end

data/lib/taperole/core/installer.rb

@@ -0,0 +1,87 @@
+require 'pathname'
+
+module Taperole
+  module Installer
+    include Taperole::Helpers::Files
+    include Thor::Actions
+
+    protected
+
+    def install_tape
+      add_tape_to_gitignore
+      mkdir tapefiles_dir
+      create_tape_files
+      create_roles_dir
+      create_inventory_file
+      create_ssh_keys_dir
+      handle_vagrantfile
+    end
+
+    def uninstall_tape
+      rm "#{tapefiles_dir}/omnibox.yml"
+      rm "#{tapefiles_dir}/deploy.yml"
+      rm "#{tapefiles_dir}/tape_vars.yml"
+      rm "#{tapefiles_dir}/rake.yml"
+      rm "#{tapefiles_dir}/roles"
+      rm "#{tapefiles_dir}/hosts"
+      rm "#{local_dir}/dev_keys"
+      rm "#{local_dir}/Vagrantfile"
+    end
+
+    private
+
+    def add_tape_to_gitignore
+      File.open('.gitignore', 'r+') { |f| f.puts '.tape' unless f.read =~ /^\.tape$/ }
+    end
+
+    def create_tape_files
+      if fe_app? && !rails_app?
+        logger.info '🔎  JS/HTML app detected'.red
+        copy_static_app_examples
+      elsif rails_app?
+        logger.info '🔎  Rails app detected'.red
+        copy_basic_examples
+      end
+    end
+
+    def copy_static_app_examples
+      %w(omnibox deploy tape_vars).each do |base_filename|
+        copy_example(
+          "templates/static_html/#{base_filename}.example.yml",
+          "#{tapefiles_dir}/#{base_filename}.yml"
+        )
+      end
+    end
+
+    def copy_basic_examples
+      %w(omnibox deploy tape_vars rake).each do |base_filename|
+        copy_example(
+          "templates/base/#{base_filename}.example.yml",
+          "#{tapefiles_dir}/#{base_filename}.yml"
+        )
+      end
+    end
+
+    def create_roles_dir
+      mkdir "#{tapefiles_dir}/roles"
+      `touch #{tapefiles_dir}/roles/.keep`
+    end
+
+    def create_inventory_file
+      copy_example 'templates/base/hosts.example', "#{tapefiles_dir}/hosts"
+    end
+
+    def create_ssh_keys_dir
+      mkdir "#{local_dir}/dev_keys"
+    end
+
+    def handle_vagrantfile
+      if options[:vagrant].nil?
+        options[:vagrant] = ask('Are you going to use vagrant? (y/n): ')
+      end
+      if options[:vagrant]
+        copy_example 'Vagrantfile', 'Vagrantfile'
+      end
+    end
+  end
+end

data/lib/taperole/core/notifier.rb

@@ -0,0 +1,47 @@
+require 'singleton'
+require 'yaml'
+
+module Taperole
+  class Notifier
+    include ::Singleton
+
+    attr_accessor :observers
+
+    def initialize
+      @observers = []
+    end
+
+    class << self
+      include Taperole::Helpers::Files
+
+      def register_notifiers(options)
+        if config["slack_webhook_url"]
+          slack_notifier = Taperole::Notifiers::Slack.new(
+            config["slack_webhook_url"],
+            deploy_info(options)
+          )
+          instance.observers.push(slack_notifier)
+        end
+      end
+
+      def config
+        @config ||= YAML.load_file("#{tapefiles_dir}/tape_vars.yml")
+      end
+
+      def deploy_info(options)
+        {
+          app_name: config["app_name"],
+          user: `whoami`.chomp,
+          hosts: options[:limit] || 'default',
+          repo: config["be_app_repo"] || ''
+        }
+      end
+
+      def notify_observers(state)
+        instance.observers.each do |observer|
+          observer.update(state)
+        end
+      end
+    end
+  end
+end

data/lib/taperole/helpers/files.rb

@@ -0,0 +1,76 @@
+module Taperole
+  module Helpers
+    module Files
+      def fe_app?
+        !Dir["#{local_dir}/package.json"].empty?
+      end
+
+      def rails_app?
+        !Dir["#{local_dir}/config.ru"].empty?
+      end
+
+      def tape_dir
+        File.realpath(File.join(__dir__, '../../../'))
+      end
+
+      def local_dir
+        Dir.pwd
+      end
+
+      def tapefiles_dir
+        local_dir + '/taperole'
+      end
+
+      def tapecfg_dir
+        local_dir + '/.tape'
+      end
+
+      def rm(file)
+        logger.info 'Deleting '.red + file
+        FileUtils.rm_r file
+      end
+
+      def mkdir(name)
+        file_text = "#{::Pathname.new(name).basename}: "
+        begin
+          FileUtils.mkdir name
+          success(file_text)
+        rescue Errno::EEXIST
+          exists(file_text)
+        rescue StandardError => e
+          error(file_text)
+          raise e
+        end
+      end
+
+      def copy_example(file, cp_file)
+        file_text = "#{::Pathname.new(cp_file).basename}: "
+        begin
+          if File.exist?(cp_file.to_s)
+            exists(file_text)
+          else
+            FileUtils.cp("#{tape_dir}/#{file}", cp_file.to_s)
+            success(file_text)
+          end
+        rescue StandardError => e
+          error(file_text)
+          raise e
+        end
+      end
+
+      private
+
+      def success(file_text)
+        logger.info file_text + '✔'.green
+      end
+
+      def error(file_text)
+        logger.info file_text + '✘'.red
+      end
+
+      def exists(file_text)
+        logger.info file_text + '✘ (Exists)'.yellow
+      end
+    end
+  end
+end

data/lib/taperole/helpers/logging.rb

@@ -0,0 +1,37 @@
+require 'logger'
+
+module Taperole
+  module Helpers
+    module Logging
+      def initialize(*_args)
+        super
+        logger.level = logger_level
+        logger.formatter = proc do |_severity, _datetime, _progname, msg|
+          "#{msg}\n"
+        end
+      end
+
+      def logger
+        Logging.logger
+      end
+
+      def self.logger
+        @logger ||= Logger.new(STDOUT)
+      end
+
+      private
+
+      def logger_level
+        if options[:debug]
+          Logger::DEBUG
+        elsif options[:verbose]
+          Logger::INFO
+        elsif options[:quiet]
+          Logger::ERROR
+        else
+          Logger::INFO
+        end
+      end
+    end
+  end
+end