roro 0.2.4 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 639ba3036903d8a486608ec5b07f79bf4330e05823b21d7eab7f9f3fde803c62
-  data.tar.gz: 06bb7ab5697e76eba09a77586b21eb213352df9fd971662ee893c211ed364ae1
+  metadata.gz: 999f9916a8bcac4281835fbec6b843e19436b62c43e103945a9e5ebcf09d741e
+  data.tar.gz: f6484791b8829df9c2d8a776a86e9ec4e1b0e1afba35cd92df60ab73faced09b
 SHA512:
-  metadata.gz: 72b53d0e0cd9cf98914a9dc00921106fbfd68b2ab5452608722a3ee090bc384e74b8e275f5034480fa9f99667fac10912ae4e6c6a2004be28bcf317ddd5f5809
-  data.tar.gz: 7afa2da9a34364e493457d239ddff73b9791ad519993237fcc779140d90f21d6edd31c91de6878af66896df6a8907bf160bc8104d082ab4e937558c7bdb014ae
+  metadata.gz: c136c9d690376e0d82e6f79e71a2485854b77caf640e81b634509e336f0a1f4b3a615e7ff84982b4008bacb9bdbfa33107b42b28ab1b04052dcfc1bd51c4bf9f
+  data.tar.gz: 46087ecabf31acd42ddc93922518053279ec1519488919608a658e38c2491d9ed498fba1d56b7f68e603dcea4c410b7775f9b7d78ac0d9f5a79773b222fcf7a9

data/README.md

@@ -1,16 +1,23 @@
-# Roro
+# RoRo
 
-Roro gives developers a handsome way to create, test, integrate, and deploy Ruby on Rails applications using Guard, CircleCI, Docker, Docker Compose.
+RoRo is a containerization and continuous integration framework for Ruby applications. Like Rails, it favors convention over configuration. It aims to provide everything you need to:
 
-## Installation
+1. Greenfield a Rails app in its own container that can talk to a separate Postgresql container.
+2. Containerize your existing application and database in development.
+3. Run your tests with Guard in a separate container.
+4. Roll your containers onto CircleCI for testing.
+5. Roll your containers off of CircleCI to your servers.
 
+## Getting started
+
+### Install
+
+RoRo can be installed
 ```bash
 $ gem install roro
 ```
 
-## Usage
-
-Once installed, Roro provides a CLI:
+Once installed, RoRo provides a CLI:
 
 ```bash
 $ roro --help
@@ -25,84 +32,134 @@ Commands:
   roro ruby_gem        # Generate files for containerized gem testing, Circle...
 ```
 
-## Installing Docker and Docker Compose 
+However to use RoRo
+
+
+### Docker and Docker Compose 
 
-Before using Roro's 'greenfield' and 'rollon' commands, you'll need Docker and Docker Compose. To see if Docker is installed:
+You'll need [Docker](https://docs.docker.com/install/) and [Docker Compose](https://docs.docker.com/compose/install/). To confirm Docker is installed:
 
 ```bash
 $ docker -v
 Docker version 18.03.1-ce, build 9ee9f40
 ```
 
-Instructions for installing [Docker](https://docs.docker.com/install/). To see if Docker Compose is installed:
+To confirm Docker Compose is installed:
 
 ```bash
 $ docker-compose -v
 docker-compose version 1.21.0, build 5920eb0
 ```
 
-Instructions for installing [Docker Compose](https://docs.docker.com/compose/install/).
-
-## Greenfielding a dockerized app:
+### Greenfielding a dockerized app
 
 ```bash
 $ mkdir -p handsome_app
 $ cd handsome_app
 $ roro greenfield
-$ docker-compose up
 ```
 
-You should now be able to see the Rails welcome screen upon clicking [http://localhost:3000/](http://localhost:3000/). 
+It'll take a few minutes for Docker to download your images, copy your files, and build your application but once finished, you'll see the Rails welcome screen at [http://localhost:3000](http://localhost:3000/). 
 
-If you're on a linux machine and run into issues, please see the
-[linux notes](#linux-notes).
+### Rolling onto an existing app
 
+Whether using your own app or one greenfielded using instructions above, first shut down any running docker containers: 
 
-### Rolling onto an existing app:
+```bash
+$ docker-compose down
+```
 
-Using your own app or one generated using the 'greenfield' instructions above: 
+Then, roll RoRo on:
 
 ```bash
-$ docker-compose down
 $ roro rollon
-$ docker-compose up
 ```
 
-You should now be able to see the Rails welcome screen upon clicking [http://localhost:3000/](http://localhost:3000/). 
+If your host machine runs a flavor of linux, ensure its logged in user owns the generated files:
+
+```bash
+$ sudo chown <username><user group> -R .
+```
+
+And spin it up:
 
-## Securing environment files 
+```bash
+$ docker-compose up --build
+``` 
 
-Roro gives provides conventions for securing your environment files. To store a variable for use in your development environment, create a file with that variable, name it "development.env," and store it in docker/env_files like so:
+As with greenfielding above, wait a few minutes, and when it's finished, open [http://localhost:3000/](http://localhost:3000/). 
+
+
+### Guard and tests
+
+From another terminal: 
+
+```bash
+$ docker-compose exec app bundle exec guard
+```
+
+To use LiveReoload with Guard, install the Chrome [extension](https://chrome.google.com/webstore/detail/livereload/jnihajbhpnppcggbcgedagnkighmdlei?hl=en):
+
+
+## Deployment 
+
+### Securing environment files 
+
+Roro provides conventions for securing sensitive variables between docker containers and environments. To store a variable for use in development, create a file with that variable inside, name it "development.env," and store it in docker/env_files. Here's a one-liner:
+
+```bash 
+$ echo "export EXAMPLE_KEY=example_value" > docker/env_files/development.env
+```
+
+Next, generate a key for the development environment:
 
 ```bash 
-$ echo "export export EXplace to put environment files for use in dockerized environments. AMPLE_KEY=example_value" > docker/env_files/development.env
 $ roro generate_key development
+```
+
+Then encrypt the development.env file using the previously generated development key:
+
+```bash 
 $ roro obfuscate development
 ```
 
-You should now see an environment file and its encrypted counterpart in docker/env_files: 
+You should now have the environment file and its encrypted counterpart: 
 
 ```bash 
 $ ls docker/env_files
 development.env  development.env.enc
 ```
 
-To expose a previously obfuscated file:
+To see how decryption works, first back up a copy of your development.env file:
 
 ```bash 
 $ mv docker/env_files/development.env docker/env_files/backup.env
+```
+
+Then expose its encrypted counterpart:
+
+```bash 
 $ roro expose development
 ```
 
-To verify the newly decrypted file contents match its backup:
+You should now have three files:
+
+```bash 
+$ ls docker/env_files
+backup.env  development.env  development.env.enc 
+```
+
+To verify the newly decrypted file's contents match those of its backup:
 
 ```bash 
 $ diff docker/env_files/development.env docker/env_files/backup.env 
 ```
 
-## Linux notes
+## Notes 
 
-If you're on a linux machine, you may need to change ownership of the newly created files:
+### Linux
+
+If you're running linux you may need to change ownership of the newly created files, prepend commands with sudo, or both. To change ownership of newly generated files:
 
 ```bash
 $ sudo chown <username><user group> -R .
@@ -110,34 +167,54 @@ $ sudo chown <username><user group> -R .
 
 If that doesn't work, Docker's [documentation](https://docs.docker.com/install/linux/linux-postinstall/#manage-docker-as-a-non-root-user) should get you pointed in the right direction.
 
-## Troubleshooting 
+### Troubleshooting 
+
+#### Port in use 
 
-Sometimes the port is in use. This could be because you have a server running on your host machine, or because Docker is running a server and piping it to the host. To shut down a server running in Docker, do:
+Sometimes you will ge a message saying the port specified in your docker-compose.yml file is already in use. This may be because you have a server running on your host from normal development, or because another Docker container is running a server and piping it to your host. If the former you can shut it down using ctrl^c, and if the latter:
 
 ```
 $ docker-compose down 
 ``` 
 
-Sometimes shutting down all servers doesn't work, because Rails still thinks a server is already running, which is usuall because there's a .pid file somewhere. 
+Sometimes shutting down all servers isn't enough because a .pid file remains. You can usually remove it with: 
 
+```bash
 $ rm /tmp/pids/server.pid
+```
 
-Sometimes you just need a fresh start. To remove all images, containers, and volumes from your system:
+If that doesn't work, restart your machine.
 
-$ docker system prune -af --volumes
+#### Mismatched ruby versions 
 
-## Contributing
+Sometimes your Gemfile will specify a ruby version which doesn't match the ruby version of the image your container is using. There are three ways to handle this. The first way is to specify an image with the same version of ruby as is in your Gemfile. Open your Dockerfile and change:
 
-This gem and the associated practices are just a way of deploying your application, not the canonical or best way. If you have suggestions on how to make it easier, more secure, quicker or better, please share them. If you have specific ideas, please fork the repo, make your changes, write your tests, and send me a pull request.    
+```
+FROM ruby:2.5
+```
+to:
+```
+FROM ruby:2.5.x
+```
+...where 2.5.x is the ruby specified in your Gemfile. The second way is to specify the same version of ruby in your app container's image as at the top of your Gemfile:
 
-## License
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+```ruby 
+ruby '2.5.x'
+``` 
 
+The third way is to remove the ruby specification from your Gemfile, relying on your Dockerfile for ruby version management.
 
- should get you pointed in the right direction. , you may need to prepend 'sudo' to the above command, or chown newly created files:
+#### Get out of jail
+
+To remove all images, containers, and volumes from your system and start over:
 
 ```bash
-$ sudo chown <username><user group> -R .
+$ docker system prune -af --volumes
 ```
 
-If that doesn't work, Docker's [documentation](https://docs.docker.com/install/linux/linux-postinstall/#manage-docker-as-a-non-root-user) should get you pointed in the right direction.
+## Contributing
+
+This gem and its associated practices are just one way of using these tools and not the canonical way. My purpose in publishing it is to get a conversation started about what conventions around these tools might look like. If you have ideas on how to make it better please put in an issue -- or fork the repo, make your changes, write your tests, and send me a pull request. It'll make me feel warm inside.    
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/roro/cli/templates/docker-compose.yml

@@ -30,6 +30,7 @@ services:
 
   database:
     image: postgres
+    
     env_file:
       - docker/containers/database/development.env
 
@@ -37,10 +38,11 @@ services:
       - database-data:/var/lib/postgresql/data
 
   web:
+    depends_on:
+      - app
     build:
       context: .
       dockerfile: docker/containers/web/Dockerfile
-
 volumes:
   database-data:
   gem_cache:

data/lib/roro/version.rb

@@ -1,3 +1,3 @@
 module Roro
-  VERSION = "0.2.4"
+  VERSION = "0.2.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: roro
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.5
 platform: ruby
 authors:
 - schadenfred
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-16 00:00:00.000000000 Z
+date: 2019-04-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor