stack_car 0.8.0 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 185a0b49e3f2bdac8994507a50f3454d1455df64
-  data.tar.gz: 1a924d44567950615378184317b421e9c9ccee51
+SHA256:
+  metadata.gz: 80132883ba506f9cf4414a46f560a2040e8843596b7a94e3d6f9baab6ae3a4d4
+  data.tar.gz: bb84c75a79f699e7bb04aa877eaed36f3acb9e8c8d9bf294d9f4fa7bbe579ddc
 SHA512:
-  metadata.gz: c65cd894261123a12ebf2ac3f47a39b57a44aea50f87e1d481e255b755c9edc490ffa32dd4ae9e61e777be0cc3c44e89e2b43ea885ffe236da8f3540577862f1
-  data.tar.gz: 24e5e23aceb5cbd161017047ef4ee1d54b01288877d21ad3e8598659bd90b8f5c9f617c005a31e30c346bff01295ca2dbff3037737bfe7e1edfd3d53fb4e8ce6
+  metadata.gz: 1e03c8620fcd08038774e75c2cfeefa75a2bae7d42708c0240c774e3584391695a87349c50bba6b0c7b444e46e66d73b2e96b1439bbf09f0104670b83e3fb831
+  data.tar.gz: 3196614e6fd6ce06b7408aa292e4ae0b19ef57aa9df8643899fcf378ad840a2d4d469695010ca04948676b9a46b7b655947cbaa0bf686c59c27b3b385b73341a

data/.gitlab-ci.yml

@@ -1,17 +1,22 @@
-image: ruby:2.3
+stages:
+  - rspec 
 
 before_script:
-  bundle
+  - bundle
 
-pages:
-  script:
-  - bundle exec yardoc --plugin yard-thor -o public - templates/.* templates/* 
-  artifacts:
-    paths:
-    - public
-  only:
-  - master 
+# pages:
+#   script:
+#   - bundle exec yardoc --plugin yard-thor -o public - templates/.* templates/* 
+#   artifacts:
+#     paths:
+#     - public
+#   only:
+#   - master 
 
-test:
+rspec:
+  stage: rspec
+  image: ruby:2.3
   script:
-    bundle exec rake
+    - bundle exec rspec
+  tags:
+    - docker

data/README.md

@@ -4,6 +4,13 @@
 
 Stack Car is an opinionated set of tools around Docker and Rails.  It provides convenent methods to start and stop docker-compose, to deploy with rancher and a set of templates to get a new Rails app in to docker as quickly as possible.
 
+## Table of Contents
+
+- [Installation](#installation)
+- [Usage](#usage)
+- [Development](#development)
+- [Dockerizing an Application](#dockerizing-an-application)
+- [Generating a Helm Chart](#generating-a-helm-chart)
 
 ## Installation
 
@@ -33,7 +40,121 @@ Commands:
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+**To install this gem onto your local machine**
+- Run `bundle exec rake install`
+
+### Workflow
+
+**Create a dummy rails app**
+
+Developing stack_car often requires a rails application for you to run updated commands and templates against. Generate one for this purpose:
+- `rails new <dummy-app-name>`
+
+**Make and test your changes**
+- In stack_car, make your command / template changes
+- Run `rake install` to update your local gem
+- In your dummy application, test the updated command
+- Commit your changes
+
+### Releasing a new version
+- Update the version number in `version.rb`
+- Run `bundle exec rake release`
+  - This will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Dockerizing an application
+
+Dockerizing your application with stack_car can be thought of in 2 steps:
+- **Generate the file templates**
+- **Customize provided templates to the requirements of the application**
+
+### Generate templates (`sc dockerize`)
+You can generate requisite files for running your application for local development in Docker with the **dockerize** command.
+
+To **dockerize** your application:
+- `cd` into your project dir
+- Run `sc dockerize` to generate files, appending **service flags** to scaffold any other services your application requires
+  - **For example**:
+    - For rails/postgres: `sc dockerize --postgres`
+    - For rails/mysql/redis: `sc dockerize --mysql --redis`
+
+This command will provide:
+- `Dockerfile`
+- `docker-compose.yml`
+- `.env*` files
+-  **ops** files to get you set up for running your application with **nginx**.
+
+### Customize templates
+
+stack_car will have provided sensible defaults for your services but customization will be required per needs of each project (ie api tokens and email configuration where applicable).
+
+**Customization workflow**
+- Do a text search to find and replace any instances `CHANGEME` in the generated files
+- Add any **general environment variables** to `.env`
+  - This sets defaults for all docker compose environments
+- Add any **development environment variables** to `.env.development` 
+  - These set up any new values or overrides specific to your development env
+- Run `sc build` to build your image
+  - On failed build, browse the terminal output to track down and squash any misconfigurations. Rebuild
+- Upon successful build, run `sc up` to spin up project
+  - If you get errors, browse the terminal output to track down and squash any misconfigurations (refer to the Docker dashboard to see separate logs for each service)
+- Visit site at `localhost:3000`
+  - Alternatively, visit it at the host you have specified to work with **Dory**
+- **Note**: *Depending on the DB required by your application, you will need to create the DB. You need to do that within from the container:*
+  - Using the `bundle-exec` command: `sc bundle-exec db:create`
+  - Shelling in and running in the container shell:
+  ```bash
+      sc exec bash
+      bundle exec rails db:create
+  ```
+
+Once all services are running and speaking to each other you are good to go.
+
+**Tips**:
+- Any changes to `Dockerfile` will require `sc build` for the changes to manifest
+- Changes to `docker-compose.yml` **do not require rebuild unless you have changed the image**
+
+## Generating a Helm Chart
+
+stack_car's **dockerize** command can be used in conjunction with available flags to generate a **Helm chart** template for your application. You will need to create the *values* files with necessary configuration values from the *sample-values* provided by stack_car, but the command will effectively give you the baseline Notch8 template (scripts, template files, template helpers, sample values file) for a **Helm base Kubernetes deploy**
+
+The following examples are to be run in the repo of the application you are creating the chart for.
+
+**To generate a Helm chart template**
+
+- `sc dockerize --helm`
+  - This command without additional flags will only generate Rails web related template files
+
+In broad strokes adding additional flags signals stack_car to generate template files for other services. Note that any configuration that would normally be applied for these services in a non Helm context (without the `--helm` flag) still apply.
+
+**For example**:
+- `sc dockerize --helm --fcrepo --solr`
+  - This command will add templates for the **fcrepo** service and add a **solr chart dependency** in the `Chart.yaml` (You can think of `Chart.yaml` like the **Gemfile** or **package.json** of a Helm chart)
+
+**Creating values files**
+
+Values files allows you to configure your helm deploy from number of web instances to hostname for your ingress to environment variables required by your application.
+
+When starting from a new helm chart, you'll want to copy the sample values file to one named after the environment you're creating a deployment for.
+
+For example:
+`cp sample-values.yaml staging-values.yaml`
+
+*Note: You will do this once for every environment you'd like to deploy*
+
+**Handling values files**
+
+Since values files are likely to contain sensitive information like API keys, they should never be committed to your repository. The scripts that stack_car includes in your chart simplifies encrypting and decrypting values for version control.
+
+Example workflow (given values file is already created):
+- Edit values file
+- `bin/encrypt-secrets`
+  - This command will create/update `staging-values.yaml.enc`
+- Commit and push
+
+When pulling down a repo or branch, you will need to start by decrypting.
+
+Example:
+- `bin/decrypt-secrets`
 
 ## Contributing
 

data/lib/stack_car/cli.rb

@@ -1,7 +1,8 @@
 require 'thor'
 require 'erb'
 require 'dotenv/load'
-
+require 'json'
+require 'byebug'
 module StackCar
   class HammerOfTheGods < Thor
     include Thor::Actions
@@ -19,114 +20,180 @@ module StackCar
     method_option :logs, default: true, type: :boolean
     desc "up", "starts docker-compose with rebuild and orphan removal, defaults to web"
     def up
+      setup
+      ensure_development_env
       args = ['--remove-orphans']
       args << '--build' if options[:build]
       if options[:build]
-        run("docker-compose pull #{options[:service]}")
+        run("#{dotenv} docker-compose pull #{options[:service]}")
       end
 
-      run_with_exit("docker-compose up #{args.join(' ')} #{options[:service]}")
+      run_with_exit("#{dotenv} docker-compose up #{args.join(' ')} #{options[:service]}")
     end
 
     method_option :service, default: '', type: :string, aliases: '-s'
     desc "stop", "stops the specified running service, defaults to all"
     def stop
-      run("docker-compose stop #{options[:service]}")
+      setup
+      ensure_development_env
+      run("#{dotenv} docker-compose stop #{options[:service]}")
       run_with_exit("rm -rf tmp/pids/*")
     end
-    map down: :stop
+
+    method_option :volumes, aliases: '-v'
+    method_option :rmi
+    method_option :'remove-orphans'
+    method_option :service, aliases: '-s'
+    method_option :timeout, aliases: '-t'
+    method_option :all, aliases: '-a'
+    method_option :help, aliases: '-h'
+    desc 'down', 'stops and removes containers and networks specific to this project by default, run with -h for more options'
+    def down
+      setup
+      ensure_development_env
+
+      if options[:help]
+        run('docker-compose down --help')
+        say 'Additional stack_car options:'
+        say '    -a, --all               Removes all containers, networks, volumes, and'
+        say '                            images created by `up`.'
+        say '    -s, --service           Specify a service defined in the Compose file'
+        say '                            whose containers and volumes should be removed.'
+        exit(0)
+      end
+
+      if options[:service]
+        rm_vol = true if options[:volumes]
+
+        remove_container(options[:service], rm_vol)
+        exit(0)
+      end
+
+      run_conf = 'Running down will stop and remove all of the Docker containers and networks ' \
+                 'defined in the docker-compose.yml file. Continue?'
+      prompt_run_confirmation(run_conf)
+
+      args = []
+      if options[:all]
+        prompt_run_confirmation('--all will remove all containers, volumes, networks, local images, and orphaned containers. Continue?')
+
+        args = %w[--volumes --rmi=local --remove-orphans]
+      else
+        args << '--volumes' if options[:volumes]
+        args << '--rmi=local' if options[:rmi]
+        args << '--remove-orphans' if options[:'remove-orphans']
+        args << '--timeout' if options[:timeout]
+      end
+
+      run("#{dotenv} docker-compose down #{args.join(' ')}")
+      run_with_exit('rm -rf tmp/pids/*')
+    end
 
     method_option :service, default: 'web', type: :string, aliases: '-s'
     desc "build", "builds specified service, defaults to web"
     def build
-      run_with_exit("docker-compose build #{options[:service]}")
+      setup
+      ensure_development_env
+      run_with_exit("#{dotenv} docker-compose build #{options[:service]}")
     end
 
     method_option :service, default: 'web', type: :string, aliases: '-s'
     desc "push ARGS", "wraps docker-compose push web unless --service is used to specify"
     def push(*args)
-      run_with_exit("docker-compose push #{options[:service]} #{args.join(' ')}")
+      setup
+      run_with_exit("#{dotenv} docker-compose push #{options[:service]} #{args.join(' ')}")
     end
 
     method_option :service, default: 'web', type: :string, aliases: '-s'
     desc "pull ARGS", "wraps docker-compose pull web unless --service is used to specify"
     def pull(*args)
-      run_with_exit("docker-compose pull #{options[:service]} #{args.join(' ')}")
+      setup
+      run_with_exit("#{dotenv} docker-compose pull #{options[:service]} #{args.join(' ')}")
     end
 
     method_option :service, default: '', type: :string, aliases: '-s'
     desc "ps ARGS", "wraps docker-compose pull web unless --service is used to specify"
     def ps(*args)
-      run_with_exit("docker-compose ps #{options[:service]} #{args.join(' ')}")
+      setup
+      run_with_exit("#{dotenv} docker-compose ps #{options[:service]} #{args.join(' ')}")
     end
     map status: :ps
 
     method_option :service, default: 'web', type: :string, aliases: '-s'
     desc "bundle ARGS", "wraps docker-compose run web unless --service is used to specify"
     def bundle(*args)
-      run_with_exit("docker-compose exec #{options[:service]} bundle")
+      setup
+      run_with_exit("#{dotenv} docker-compose exec #{options[:service]} bundle")
     end
 
     method_option :service, default: 'web', type: :string, aliases: '-s'
     desc "walk ARGS", "wraps docker-compose run web unless --service is used to specify"
     def walk(*args)
-      run_with_exit("docker-compose run #{options[:service]} #{args.join(' ')}")
+      setup
+      run_with_exit("#{dotenv} docker-compose run #{options[:service]} #{args.join(' ')}")
     end
 
     method_option :service, default: 'web', type: :string, aliases: '-s'
     desc "exec ARGS", "wraps docker-compose exec web unless --service is used to specify"
     def exec(*args)
-      run_with_exit("docker-compose exec #{options[:service]} #{args.join(' ')}")
+      setup
+      run_with_exit("#{dotenv} docker-compose exec #{options[:service]} #{args.join(' ')}")
     end
     map ex: :exec
 
     method_option :service, default: 'web', type: :string, aliases: '-s'
     desc 'sh ARGS', "launch a shell using docker-compose exec, sets tty properly"
     def sh(*args)
-      run_with_exit("docker-compose exec -e COLUMNS=\"\`tput cols\`\" -e LINES=\"\`tput lines\`\" #{options[:service]} bash #{args.join(' ')}")
+      setup
+      run_with_exit("#{dotenv} docker-compose exec -e COLUMNS=\"\`tput cols\`\" -e LINES=\"\`tput lines\`\" #{options[:service]} bash #{args.join(' ')}")
     end
 
     method_option :service, default: 'web', type: :string, aliases: '-s'
     desc "bundle_exec ARGS", "wraps docker-compose exec web bundle exec unless --service is used to specify"
     def bundle_exec(*args)
-      run_with_exit("docker-compose exec #{options[:service]} bundle exec #{args.join(' ')}")
+      setup
+      run_with_exit("#{dotenv} docker-compose exec #{options[:service]} bundle exec #{args.join(' ')}")
     end
     map be: :bundle_exec
 
     method_option :service, default: 'web', type: :string, aliases: '-s'
     desc "console ARGS", "shortcut to start rails console"
     def console(*args)
-      run_with_exit("docker-compose exec #{options[:service]} bundle exec rails console #{args.join(' ')}")
+      setup
+      run_with_exit("#{dotenv} docker-compose exec #{options[:service]} bundle exec rails console #{args.join(' ')}")
     end
     map rc: :console
 
     desc "release ENVIRONTMENT", "tag and push and image to the registry"
     def release(environment)
+      setup
       timestamp = Time.now.strftime("%Y%m%d%I%M%S")
       sha = `git rev-parse HEAD`[0..8]
       registry = "#{ENV['REGISTRY_HOST']}#{ENV['REGISTRY_URI']}"
       tag = ENV["TAG"] || 'latest'
       unless File.exists?("#{ENV['HOME']}/.docker/config.json") && File.readlines("#{ENV['HOME']}/.docker/config.json").grep(/#{ENV['REGISTRY_HOST']}/).size > 0
-        run_with_exit("docker login #{ENV['REGISTRY_HOST']}")
+        run_with_exit("#{dotenv(environment)} docker login #{ENV['REGISTRY_HOST']}")
       end
-      run_with_exit("docker tag #{registry}:#{tag} #{registry}:#{environment}-#{timestamp}")
-      run_with_exit("docker push #{registry}:#{environment}-#{timestamp}")
-      run_with_exit("docker tag #{registry}:#{tag} #{registry}:#{sha}")
-      run_with_exit("docker push #{registry}:#{sha}")
-      run_with_exit("docker tag #{registry}:#{tag} #{registry}:#{environment}-latest")
-      run_with_exit("docker push #{registry}:#{environment}-latest")
-      run_with_exit("docker tag #{registry}:#{tag} #{registry}:latest")
-      run_with_exit("docker push #{registry}:latest")
+      run_with_exit("#{dotenv(environment)} docker tag #{registry}:#{tag} #{registry}:#{environment}-#{timestamp}")
+      run_with_exit("#{dotenv(environment)} docker push #{registry}:#{environment}-#{timestamp}")
+      run_with_exit("#{dotenv(environment)} docker tag #{registry}:#{tag} #{registry}:#{sha}")
+      run_with_exit("#{dotenv(environment)} docker push #{registry}:#{sha}")
+      run_with_exit("#{dotenv(environment)} docker tag #{registry}:#{tag} #{registry}:#{environment}-latest")
+      run_with_exit("#{dotenv(environment)} docker push #{registry}:#{environment}-latest")
+      run_with_exit("#{dotenv(environment)} docker tag #{registry}:#{tag} #{registry}:latest")
+      run_with_exit("#{dotenv(environment)} docker push #{registry}:latest")
     end
 
     desc "provision ENVIRONMENT", "configure the servers for docker and then deploy an image"
     def provision(environment)
+      setup
       # TODO make dotenv load a specific environment?
-      run_with_exit("DEPLOY_ENV=#{environment} dotenv ansible-playbook -i ops/hosts -l #{environment}:localhost ops/provision.yml")
+      run_with_exit("DEPLOY_ENV=#{environment} #{dotenv(environment)} ansible-playbook -i ops/hosts -l #{environment}:localhost ops/provision.yml")
     end
 
     desc "ssh ENVIRONMENT", "log in to a running instance - requires PRODUCTION_SSH to be set"
     def ssh(environment)
+      setup
       target = ENV["#{environment.upcase}_SSH"]
       if target
         run_with_exit(target)
@@ -137,22 +204,27 @@ module StackCar
 
     desc "deploy ENVIRONMENT", "deploy an image from the registry"
     def deploy(environment)
-      run_with_exit("DEPLOY_HOOK=$DEPLOY_HOOK_#{environment.upcase} dotenv ansible-playbook -i ops/hosts -l #{environment}:localhost ops/deploy.yml")
+      setup
+      run_with_exit("DEPLOY_HOOK=$DEPLOY_HOOK_#{environment.upcase} #{dotenv(environment)} ansible-playbook -i ops/hosts -l #{environment}:localhost ops/deploy.yml")
     end
 
-    method_option :elasticsearch, default: false, type: :boolean, aliases: '-e'
-    method_option :solr, default: false, type: :boolean, aliases: '-s'
-    method_option :postgres, default: false, type: :boolean, aliases: '-p'
-    method_option :mysql, default: false, type: :boolean, aliases: '-m'
-    method_option :redis, default: false, type: :boolean, aliases: '-r'
     method_option :delayed_job, default: false, type: :boolean, aliases: '-j'
-    method_option :fcrepo, default: false, type: :boolean, aliases: '-f'
     method_option :deploy, default: false, type: :boolean, aliases: '-d'
+    method_option :elasticsearch, default: false, type: :boolean, aliases: '-e'
+    method_option :fcrepo, default: false, type: :boolean, aliases: '-f'
+    method_option :helm, default: false, type: :boolean, aliases: '-h'
+    method_option :git, default: false, type: :boolean, aliases: '-g'
     method_option :heroku, default: false, type: :boolean, aliases: '-h'
-    method_option :rancher, default: false, type: :boolean, aliases: '-dr'
-    method_option :sidekiq, default: false, type: :boolean, aliases: '-sq' # TODO
-    method_option :mongodb, default: false, type: :boolean, aliases: '-mg'
-    method_option :memcached, default: false, type: :boolean, aliases: '-mc'
+    method_option :hyku, default: false, type: :boolean, aliases: "\--hu"
+    method_option :imagemagick, default: false, type: :boolean, aliases: '-i'
+    method_option :memcached, default: false, type: :boolean, aliases: "\--mc"
+    method_option :mongodb, default: false, type: :boolean, aliases: "\--mg"
+    method_option :mysql, default: false, type: :boolean, aliases: '-m'
+    method_option :postgres, default: false, type: :boolean, aliases: '-p'
+    method_option :rancher, default: false, type: :boolean, aliases: "\--dr"
+    method_option :redis, default: false, type: :boolean, aliases: '-r'
+    method_option :sidekiq, default: false, type: :boolean, aliases: "\--sk"
+    method_option :solr, default: false, type: :boolean, aliases: '-s'
     method_option :yarn, default: false, type: :boolean, aliases: '-y'
     desc 'dockerize DIR', 'Will copy the docker tempates in to your project, see options for supported dependencies'
     long_desc <<-DOCKERIZE
@@ -163,9 +235,14 @@ module StackCar
     DOCKERIZE
     def dockerize(dir=".")
       Dir.chdir(dir)
+      self.destination_root = dir
+      setup
+      # Commandline overrides config files
+      # options = file_config.merge(options)
       @project_name = File.basename(File.expand_path(dir))
       apt_packages << "libpq-dev postgresql-client" if options[:postgres]
       apt_packages << "mysql-client" if options[:mysql]
+      apt_packages << "imagemagick" if options[:imagemagick]
       pre_apt << "echo 'Downloading Packages'"
       post_apt << "echo 'Packages Downloaded'"
 
@@ -185,13 +262,19 @@ module StackCar
         post_apt << "cd /opt && unzip fits-1.0.5.zip && chmod +X fits-1.0.5/fits.sh"
       end
 
-     ['.dockerignore', 'Dockerfile', 'Dockerfile.base', 'docker-compose.yml', 'docker-compose.ci.yml', 'docker-compose.production.yml', '.gitlab-ci.yml', '.env'].each do |template_file|
+     ['.dockerignore', 'Dockerfile', 'docker-compose.yml', '.gitlab-ci.yml', '.env'].each do |template_file|
        puts template_file
         template("#{template_file}.erb", template_file)
      end
-     template("database.yml.erb", "config/database.yml")
+     directory('.gitlab', '.gitlab')
      template(".env.development.erb", ".env.development")
      template(".env.erb", ".env.production")
+     template(".sops.yaml.erb", ".sops.yaml")
+     template("decrypt-secrets", "bin/decrypt-secrets")
+     template("encrypt-secrets", "bin/encrypt-secrets")
+     template("database.yml.erb", "config/database.yml")
+     template("development.rb.erb", "config/environments/development.rb")
+     template("production.rb.erb", "config/environments/production.rb")
 
      if File.exists?('README.md')
        prepend_to_file "README.md" do
@@ -202,14 +285,33 @@ module StackCar
          File.read("#{self.class.source_root}/README.md")
        end
      end
-     append_to_file("Gemfile", "gem 'activerecord-nulldb-adapter'")
+
+      if File.exist?('Gemfile')
+        append_to_file('Gemfile', "gem 'activerecord-nulldb-adapter'")
+      else
+        append_to_file('../Gemfile', "gem 'activerecord-nulldb-adapter'", { verbose: false })
+        # TODO: remove '../' from message after other status messages are prepended with 'stack_car/'
+       append_to_file("../Gemfile", "gem 'pronto', groups: [:development, :test]")
+       append_to_file("../Gemfile", "gem 'pronto-rubocop', groups: [:development, :test]")
+        say_status(:append, '../Gemfile')
+      end
+
       if options[:deploy] || options[:rancher]
         directory('ops')
         ['hosts', 'deploy.yml', 'provision.yml'].each do |template_file|
           template("#{template_file}.erb", "ops/#{template_file}")
         end
+
         say 'Please update ops/hosts with the correct server addresses'
-      else
+      elsif options[:helm]
+        directory('chart')
+        if options[:fcrepo]
+          directory('chart-fcrepo', 'chart/templates')
+        end
+        if options[:sidekiq]
+          directory('chart-sidekiq', 'chart/templates')
+        end
+     else
         empty_directory('ops')
       end
 
@@ -224,7 +326,7 @@ module StackCar
     protected
     def compose_depends(*excludes)
       @compose_depends = []
-      services = [:postgres, :mysql, :elasticsearch, :solr, :redis, :mongodb, :memcached] - excludes
+      services = [:fcrepo, :postgres, :mysql, :elasticsearch, :sidekiq, :solr, :redis, :mongodb, :memcached] - excludes
       services.each do |service|
         if options[service]
           @compose_depends << "      - #{service}"
@@ -264,5 +366,115 @@ module StackCar
       end
     end
 
+    def file_config
+      path = find_config(Dir.pwd)
+      if path
+        JSON.parse(File.read(path))
+      else
+        {}
+      end
+    end
+
+    def find_config(dir)
+      path = File.join(dir, '.stackcar_rc')
+      if File.exists?(path)
+        return path
+      elsif dir == "/"
+        return nil
+      else
+        return find_config(File.dirname(dir))
+      end
+    end
+
+    def ensure_development_env
+      if !File.exists?('.env.development')
+        template(".env.development.erb", ".env.development")
+      end
+    end
+
+    def dotenv(environment='development')
+      "dotenv -f .env.#{environment},.env"
+    end
+
+    def setup
+      if File.exists?('stack_car')
+        @sc_dir = true
+        Dir.chdir('stack_car')
+        self.destination_root += "/stack_car"
+      end
+      DotRc.new
+    end
+
+    def remove_container(service_name, remove_volumes)
+      container = find_container_by_service(service_name)
+
+      container.map do |id, name|
+        prompt_run_confirmation("Remove #{name} container?")
+
+        if `docker container ls --format "{{.Names}}"`.include?(name)
+          say 'Stopping container...'
+          `docker stop #{id}`
+        end
+
+        say 'Removing container...'
+        `docker container rm #{id}`
+
+        # Ensure container was removed
+        if `docker ps -aqf id=#{id}`.empty?
+          say "  Container #{name} was removed"
+        else
+          say ">>> There was an issue removing container #{name} (#{id})"
+        end
+      end
+
+      remove_volumes_mounted_to_container(@container_volume_names) if remove_volumes
+    end
+
+    def find_container_by_service(service_name)
+      container_id = `docker-compose ps -aq #{service_name}`.strip
+
+      if container_id.empty?
+        say "Unable to locate a container for the service '#{service_name}'"
+        say "Try running `docker-compose ps #{service_name}` to make sure the container exists"
+        exit(1)
+      end
+
+      get_volume_names_for_container(container_id)
+      container_name = `docker ps -af id=#{container_id} --format "{{.Names}}"`.strip
+
+      { container_id => container_name }
+    end
+
+    def remove_volumes_mounted_to_container(volumes)
+      return if volumes.empty?
+
+      prompt_run_confirmation("\n#{volumes.join("\n")}\nRemove these volume(s)?")
+      volumes.each do |v|
+        say 'Removing volume...'
+        `docker volume rm #{v}`
+
+        if `docker volume ls -q`.include?(v)
+          say ">>> There was an issue removing volume #{v}"
+        else
+          say "  Volume #{v} was removed"
+        end
+      end
+    end
+
+    def get_volume_names_for_container(container_id)
+      @container_volume_names ||= []
+      return @container_volume_names unless @container_volume_names.empty?
+
+      JSON.parse(`docker inspect --format="{{json .Mounts}}" #{container_id}`).map do |mount_info|
+        @container_volume_names << mount_info['Name'] if mount_info['Type'] == 'volume'
+      end
+
+      @container_volume_names
+    end
+
+    def prompt_run_confirmation(question)
+      response = ask(question, limited_to: %w[y n])
+      exit(1) unless response == 'y'
+    end
   end
 end