linux_provision 0.9.8 → 0.9.10

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZjE4ZDM5OWUzMGM1YWE3OTA3MmFkNmJhMDE1NjVmMGVhYzYxYzE4NQ==
+    NGY4ZmY3MzQyOWVlODIyM2ZiYzlhMmY3YzJkYTNmYmY2NmM3NDgzMw==
   data.tar.gz: !binary |-
-    YWJlMTE3MDEwZTg3YTE0ZjUxMjAyYzYzZWNjMDZkYzA2YzA1ZDFiZQ==
+    OGVmZWQ4ZDA1ZTlmOTlhYzUzYTliZWY2ZjIxMTA5NjdjYjI1MDk0MA==
 SHA512:
   metadata.gz: !binary |-
-    MTAyNWQ4OGQ4OTg3MDNhNjdlYWRlZDU4YTY5MzUwYjdkNGM0YjcxZjY4NTNk
-    NzlmYzMwY2I5ZmIyZDJkZjEzZTZmYTM3OTFlYWFlNTg3MmU3YmEwYmRlMjI3
-    MTUwNTMxMTU5MDJiNjk5OTc3ZjdhNjNkY2FhMzBiZjMwMGE5MDc=
+    MjJjMzgyZTAxZGEzNjFmYjYxYWUxNmI3NjFhNGQzODZmNGM3NmE2ODM2YmQ2
+    OGE5MWNiYzMyZjYzZTViNzExMGM0MmNiMTUyOGU0YzgxNTE1MTRhZGQ5ZmJm
+    ZGRkNjZkNWYyZjE4NDRiMjMwODFmYzA5NGVmNTNkZjg3ZTAxNGE=
   data.tar.gz: !binary |-
-    NzEwMGQzYmVjODZjM2RmNGQ4YWY5OWVmNzJlZjUyMTUxZWQ4MTlkNTBkMmM1
-    YWM5MWI2NmIyNGFhZmZmNTlhY2ZlZjQ1MDY5MjE1NzIwMDI3MjcwNWU4NjE0
-    NjI2ZWY3MGMwNmU4N2ZiZjMyNzE2OWU3ZWJmMDFmZmM1OWMwOTc=
+    NWVmMWFkNjAyZTVmMmViZWUzMDA5ZWI1NmJjYzg2OTljZjBiN2EzMDViYzMx
+    OGUxYzg3Njg5OWZmYWY0ZWY5NmNmODU0MTcxM2E2ZGNiOTI4NzNhMDZhNzAw
+    NjkwZDkwN2E0NjNlZGY2M2UyNDdhZjY2YTZlOGEzODdiZmQ4MWQ=

data/.linux_provision.json

@@ -1,19 +1,20 @@
 {
   "node": {
-    "domain": "22.22.22.22",
-    "port": "22",
-    //"domain": "192.168.59.103",
-    //"port": "42222",
+    //"domain": "22.22.22.22",
+    //"port": "22",
+    "domain": "192.168.59.103",
+    "port": "42222",
     "user": "vagrant",
     "password": "vagrant",
     "home": "/home/vagrant",
+    "simulate": true,
     "remote": true
   },
 
   "project": {
     "home": "#{node.home}/demo",
     "ruby_version": "1.9.3",
-    "gemset": "linux_provision"
+    "gemset": "linux_provision_demo"
   },
 
   "postgres": {
@@ -27,5 +28,4 @@
     "app_user": "ruby_dev", "app_password": "ruby_dev",
     "app_schemas": ["ruby_dev_test", "ruby_dev_dev", "ruby_dev_prod"]
   }
-
 }

data/CHANGES

@@ -32,6 +32,14 @@
 
 * Adding support for docker.
 
-== Version 0.9.7
+== Version 0.9.8
+
+* Bug fix.
+
+== Version 0.9.9
+
+* Bug fixes.
+
+== Version 0.9.10
 
-* Bug fix.
+* Bug fixes.

data/Gemfile.lock

@@ -15,14 +15,14 @@ GEM
     gemspec_deps_gen (1.1.2)
       bundler
       file_utils
-    gli (2.11.0)
+    gli (2.12.1)
     highline (1.6.21)
     htmlentities (4.3.2)
     json (1.8.1)
     json_pure (1.8.1)
     mini_portile (0.6.0)
     net-ssh (2.9.1)
-    nokogiri (1.6.2.1)
+    nokogiri (1.6.3.1)
       mini_portile (= 0.6.0)
     parslet (1.6.1)
       blankslate (~> 2.0)
@@ -31,29 +31,29 @@ GEM
       rack
     rake (10.3.2)
     redcarpet (3.1.2)
-    rspec (3.0.0)
-      rspec-core (~> 3.0.0)
-      rspec-expectations (~> 3.0.0)
-      rspec-mocks (~> 3.0.0)
-    rspec-core (3.0.2)
-      rspec-support (~> 3.0.0)
-    rspec-expectations (3.0.2)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.4)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.1)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.0.0)
-    rspec-mocks (3.0.2)
-      rspec-support (~> 3.0.0)
-    rspec-support (3.0.2)
+      rspec-support (~> 3.1.0)
+    rspec-mocks (3.1.1)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.0)
     ruby-debug-base19x (0.11.30.pre15)
       debugger-ruby_core_source (> 0)
       rake (>= 0.8.1)
     ruby-debug-ide (0.4.23.beta1)
       rake (>= 0.8.1)
-    script_executor (1.5.1)
+    script_executor (1.5.3)
       highline (~> 1.6)
       json_pure (~> 1.8)
       net-ssh (~> 2.8)
       text-interpolator (~> 1.0)
-    showoff (0.9.8.1)
+    showoff (0.9.9.1)
       gli (>= 1.3.2)
       htmlentities
       json
@@ -71,7 +71,7 @@ GEM
       em-websocket (~> 0.3.6)
       eventmachine
       thin (>= 1.3.1)
-    text-interpolator (1.1.5)
+    text-interpolator (1.1.6)
     thin (1.6.2)
       daemons (>= 1.0.9)
       eventmachine (>= 1.0.0)

data/README.md

@@ -1,132 +1,582 @@
-# Linux Provision
+# Library for provisioning initial setup of Linux computer for Ruby/Rails development
 
-## Library and thor tasks for provisioning of Linux computer initial setup for Ruby/Rails development
+
+## Introduction
+
+
+Why do we need virtualization in development?
+
+* We want to have **same environment for all developers**, no matter on what platform they are working now.
+
+* We are **working on multiple projects** on same computer unit. As a result, suddenly your computer has "hidden",
+hard-to-discover inter-project dependencies or different versions of the same library.
+
+* We want to run Continuous Integration Server jobs that start services on **same ports** for different set
+of acceptance tests (isolated jobs).
+
+* To overcome **"It works on my machine!"** syndrome - when development environment is different from production environment.
+
+* Sometimes required software is **not available** on developer's platform. Example: 64-bit instant client for oracle
+was broken for almost two years on OSX  >= 10.7.
+
+* **Development for PAAS**, such as Heroku, Engine Yard etc. You can find and build virtualization that is pretty close to your platform.
+
+We will take a look at how can we do provisioning for **Vagrant** and **Docker**. Both tools are built on top of **VirtualBox**.
+
+
+## Installing and configuring Vagrant
+
+
+**Vagrant** is the wrapper around VirtualBox. It is a tool for managing virtual machines via simple to use **command line** interface. With it you can work in a clean environment based on a standard template - **base box**.
+
+In order to use Vagrant you have to install these programs:
+
+* [VirtualBox][VirtualBox]. Download it from dedicated web site and install
+it as native program. You can use it in UI mode, but it's not required.
+
+* [Vagrant][Vagrant]. Before it was distributed as ruby gem, now it's packaged as **native application**. Once installed, it will be accessible from command line as **vagrant** command.
+
+You have to decide what linux image fits your needs. I our case we use **Ubuntu 14.04 LTS 64-bit** image - it is identified with **"ubuntu/trusty64"** key.
+
+Download and install it:
 
 ```bash
-vagrant box add precise64 http://files.vagrantup.com/precise64.box
-vagrant init precise64
+vagrant box add ubuntu/trusty64 https://vagrantcloud.com/ubuntu/boxes/trusty64
+```
+
+Initialize it:
+
+```
+vagrant init ubuntu/trusty64
+```
+
+This command creates **Vagrantfile** file in the root of your project. Below is an example of such a file:
+
+```ruby
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
 
+VAGRANTFILE_API_VERSION = "2"
+
+Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
+  config.vm.box = "ubuntu/trusty64"
+end
+```
+
+You can do various commands with **vagrant** tool. For example:
+
+```bash
+vagrant up        # starts up: creates and configures guest machine
+vagrant suspend   # suspends the guest machine
+vagrant halt      # shuts down the running machine
+vagrant reload    # vagrant halt; vagrant up
+vagrant destroy   # stops machine and destroys all related resources
+vagrant provision # perform provisioning for machine
+vagrant box remove ubuntu/trusty64 # removes a box from vagrant
+```
+
+You can package currently running VirtualBox environment into reusable box:
+
+```bash
+vagrant package --vagrantfile Vagrantfile --output linux_provision.box
+```
+
+After **Vagrantfile** is generated, you can start your base box:
+
+```bash
 vagrant up
-vagrant reload
-vagrant provision
+```
 
-vagrant suspend
-vagrant halt
-vagrant destroy
-vagrant box remove precise64
+Now you have a **fully running virtual machine** in VirtualBox. You can access it through **vagrant ssh** command:
 
+```bash
 vagrant ssh
+```
+
+or **directly via ssh** (use **vagrant** password for **vagrant** user and port **2222**, this port is used as default by vagrant for ssh connections):
 
+```bash
 ssh vagrant@127.0.0.1 -p 2222
+```
 
-vagrant ssh
+You can assign IP address for your linux box, e.g.:
+
+```ruby
+Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
+  config.vm.network "private_network", ip: "22.22.22.22"
+end
+```
+
+With this configuration you can access ssh on default port:
+
+```bash
+ssh vagrant@22.22.22.22
+```
+
+Your initial setup of linux box is completed now and ready to use.
+
+
+## Installing and configuring Docker
+
+
+Docker helps you create and manage **Linux containers** - extremely lightweight VMs. Containers allow code to run in isolation from other containers. They safely share the machine's resources, all without the overhead of a hypervisor.
 
-cd /vagrant
+In order to use Docker you have to install these programs:
 
-rake db:dev:reset
+* [VirtualBox][VirtualBox].
 
-rspec
+* [boot2docker][boot2docker]. You need to install it only for non-Linux environment.
+
+ boot2docker is a lightweight Linux image made specifically to run Docker containers. It runs completely from RAM, weighs  approximately 27 MB and boots in about 5 seconds.
+
+We'll run the Docker client natively on OSX, but the Docker server will run inside our boot2docker VM. This also means that boot2docker, not OSX, is the Docker host.
+
+This command will create **boot2docker-vm** virtual machine:
+
+```bash
+boot2docker init
+```
+Go to VirtualBox UI - new VM will be added.
+ 
+Start it up:
 
-ASSET_HOST=http://22.22.22.22:3000 rails s
+```bash
+boot2docker up
 ```
 
-and then access it from the browser within [host computer](http://22.22.22.22:3000/app):
+or shut it down:
 
 ```bash
-open http://22.22.22.22:3000/app
+boot2docker down
 ```
 
+Upgrade Boot2docker VM image:
+
 ```bash
-vagrant package --vagrantfile Vagrantfile --output linux_provision.box
+boot2docker stop
+boot2docker download
+boot2docker up
 ```
 
+When docker daemon first started, it gives you recommendation about how to run docker client.
+It needs to know where docker is running, e.g.:
 
-## Docker
+```bash
+export DOCKER_HOST=tcp://192.168.59.103:2375
+```
 
+You have to setup it globally in **.bash\_profile** file or specify it each time when docker client is started.
 
-docker is an open-source project that makes creating and managing Linux containers really easy. 
-Containers are like extremely lightweight VMs – they allow code to run in isolation from other containers 
-but safely share the machine’s resources, all without the overhead of a hypervisor.
+You can access boot2docker over ssh (user: **docker**, password: **tcuser**):
 
-docker containers can boot extremely fast (in milliseconds!) which gives you unprecedented flexibility 
-in managing load across your cluster. For example, instead of running chef on each of your VMs, 
-it’s faster and more reliable to have your build system create a container and launch it on 
-the appropriate number of CoreOS hosts. When these containers start, they can signal your proxy (via etcd) 
-to start sending them traffic.
+```bash
+boot2docker ssh
+```
 
+Download the small base image named **busybox**:
 
-## Installation
+```bash
+docker pull busybox
+```
 
-* Download and install VirtualBox for OSX
+Run and test docker as separate command:
 
-https://www.virtualbox.org/wiki/Downloads
+```bash
+docker run busybox echo "hello, linus!"
+```
 
-* Install boot2docker and docker via homebrew:
+or interactively:
 
 ```bash
-brew install boot2docker
+docker run -t -i busybox /bin/sh
+```
+
+
+## Install and confige linux_provision gem
+
+Both programs - Vagrant and Docker - have their own ways to serve provisioning. Vagrant is doing it with the help of **provision** attribute. Example with simple shell script:
+
+```ruby
+Vagrant::Config.run do |config|
+  config.vm.provision :shell, :path => "bootstrap.sh"
+end
+```
+or with chef solo:
+
+```ruby
+Vagrant::Config.run do |config|
+  config.vm.provision :chef_solo do |chef|
+    ...
+  end
+end
+```
+Docker also lets you do provisioning in form of **RUN** command:
+
+```text
+# Dockerfile
+
+RUN apt-get -y -q install postgresql-9.3
 ```
-Docker will be installed as an dependency.
 
-Initialize boot2docker virtual machine:
+After multiple experiments with provisions both from Vagrant and Docker it was discovered that it is not convenient to use. It does not let you to easy install or uninstall separate packages. It's better to do it as **set of independent scripts**, separated completely from Docker and Vagrant.
+
+**linux_provision** gem is the set of such shell scripts - they install various components like postgres server, rvm, ruby etc. with the help of thor or rake script. You can see other gems that are providing similar solutions:
+for [Oracle Instant Client][oracle_client_provision] and for [OSX][osx_provision].
+
+In order to use gem add this line to your application's Gemfile:
 
 ```bash
-boot2docker init
+gem 'linux_provision'
+```
+
+And then execute:
+
+```bash
+bundle
+```
+
+Before you can start using **linux_provision** gem within your project, you need to configure it. Do the following:
+
+* Create configuration file (e.g. **.linux\_provision.json**) in json format at the root of your project. It will define your environment:
+
+```json
+{
+  "node": {
+   ...
+  },
+
+  "project": {
+    "home": "#{node.home}/demo",
+    "ruby_version": "1.9.3",
+    "gemset": "linux_provision_demo"
+  },
+
+  "postgres": {
+    "hostname": "localhost", "user": "postgres", "password": "postgres",
+    "app_user": "pg_user", "app_password": "pg_password",
+    "app_schemas": [ "my_project_test", "my_project_dev", "my_project_prod"]
+  }
+}
 ```
 
-Update .bash_profile file:
+Variables defined in this file are used by underlying shell scripts provided by the gem.
+
+In **node** section you describe destination computer where you want to install this provision.
+
+In **project** section you keep project-related info, like project **home**, project **gemset name** and **ruby version**.
+
+Last **postgres** section contains information about your postgres server.
+
+* Provide execution script
+
+Library itself if written in ruby, but for launching its code it's more convenient to use **rake** or **thor** tool. Here I provide thor script as an example:
+
+```ruby
+# thor/linux_install.thor
+
+$: << File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+require 'linux_provision'
+
+class LinuxInstall < Thor
+  @installer = LinuxProvision.new self, ".linux_provision.json"
+
+  class << self
+    attr_reader :installer
+  end
+
+  desc "general", "Installs general packages"
+  def general
+    invoke :prepare
+
+    invoke :rvm
+    invoke :ruby
 
+    invoke :postgres
+    invoke :mysql
+  end
+end
+```
+
+You can execute separate commands from script directly with **invoke** thor command. Below is fragment of such script:
 
 ```bash
-export DOCKER_HOST=tcp://127.0.0.1:4243
+#!/bin/sh
+
+#######################################
+[prepare]
+# Updates linux core packages
+
+sudo apt-get update
+
+sudo apt-get install -y curl
+sudo apt-get install -y g++
+sudo apt-get install -y subversion
+sudo apt-get install -y git
+
+#######################################
+[rvm]
+# Installs rvm
+
+curl -L https://get.rvm.io | bash
+
+#sudo chown -R vagrant /opt/vagrant_ruby
+
+#######################################
+[ruby]
+# Installs ruby
+
+USER_HOME="#{node.home}"
+
+source $USER_HOME/.rvm/scripts/rvm
+
+rvm install ruby-1.9.3
 ```
 
-Start the docker daemon:
+You can add your own scripts (e.g. demo_scripts.sh):
+
+```ruby
+class LinuxInstall < Thor
+  @installer = LinuxProvision.new self, 
+    ".linux_provision.json", 
+    [File.expand_path("demo_scripts.sh", File.dirname(__FILE__))]
+  ...
+end
+```
+
+We defined 2 new commands in demo_script.sh:
 
 ```bash
-boot2docker up
+#!/bin/sh
+
+##############################
+[project]
+# Installs demo sinatra project
+
+USER_HOME="#{node.home}"
+
+APP_HOME="#{project.home}"
+
+cd $APP_HOME
+
+source $USER_HOME/.rvm/scripts/rvm
+
+rvm use #{project.ruby_version}@#{project.gemset} --create
+
+bundle
+
+rake db:migrate
+
+
+##############################
+[rackup]
+# Starts sinatra demo application
+
+USER_HOME="#{node.home}"
+
+APP_HOME="#{project.home}"
+
+cd $APP_HOME
+
+source $USER_HOME/.rvm/scripts/rvm
+
+rvm use #{project.ruby_version}@#{project.gemset}
+
+rackup
+```
+
+## Demo application with Vagrant
+
+
+For testing purposes we have created demo web application (in **demo** folder) based on [sinatra][sinatra] framework.
+
+First, we need to inform Vagrant about the location of this application within virtual machine:
+
+```ruby
+Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
+  config.vm.synced_folder "./demo", "/home/vagrant/demo"
+end
 ```
 
-or down:
+Second, we need to configure linux_provision gem to point to right domain/port and use correct user name/password:
+
+```json
+{
+  "node": {
+    "domain": "22.22.22.22", # remote host, see "config.vm.synced_folder"
+    "port": "22",            # default ssh port
+    "user": "vagrant",       # vagrant user name
+    "password": "vagrant",   #
+    "home": "/home/vagrant", # vagrant user password
+    "remote": true
+  }
+}
+```
+
+Start your base box:
 
 ```bash
-boot2docker down
+vagrant up
 ```
 
-ssh it:
+Access linux box and find out this demo application's home:
 
 ```bash
-boot2docker ssh
+ssh vagrant@22.22.22.22
+
+pwd # /home/vagrant
+
+ls # demo
 
-# User: docker
-# Pwd:  tcuser
+cd demo
+
+ls # content of demo folder
 ```
 
-Download the small base image named busybox:
+These commands from **linux_provision** gem will build your environment for the demo project (install rvm, ruby, postgres, postgres user and posters tables):
 
 ```bash
-docker pull busybox
-docker pull ubuntu
-docker pull centos
+thor linux_install:prepare
+thor linux_install:rvm
+thor linux_install:ruby
+
+thor linux_install:postgres
+
+thor linux_install:postgres_create_user
+thor linux_install:postgres_create_schemas
+```
+
+Initialize demo project and run sinatra application:
+
+```bash
+thor linux_install:project
+
+thor linux_install:rackup
 ```
 
-Run and test as separate command:
+Now you can access application from your favorite browser:
 
 ```bash
-docker run -t -i ubuntu /bin/bash
+open http://22.22.22.22:9292
 ```
 
-and interactively:
+## Demo application with Docker
+
+You need to do very similar steps as with Vagrant. The only difference is in **linux\_provision.json** file you have to point to different host, port and user:
+
+```json
+{
+  "node": {
+    "domain": "192.168.59.103", # remote host, see boot2docker ip
+    "port": "42222",            # ssh port in docker
+    "user": "vagrant",          # vagrant user name
+    "password": "vagrant",      #
+    "home": "/home/vagrant",    # vagrant user password
+    "remote": true
+  }
+}
+```
+
+Our Dockerfile is responsible for the following base steps:
+
+* Install Ubuntu 14.4.
+
+* Install sshd (for enabling ssh).
+
+* Create vagrant user (just to in-synch with Vagrant example).
+
+* Reveal project home as /home/vagrant/demo.
+
+* Expose port 9292 (our sinatra application).
+
+Here is example:
+
+```txt
+FROM ubuntu:14.04
+
+MAINTAINER Alexander Shvets "alexander.shvets@gmail.com"
 
+# 1. Update system
+RUN sudo apt-get update
+RUN sudo locale-gen en_US.UTF-8
+
+# 2. Install sshd
+
+RUN sudo apt-get install -y openssh-server
+RUN mkdir /var/run/sshd
+RUN echo 'root:root' |chpasswd
+RUN sed --in-place=.bak 's/without-password/yes/' /etc/ssh/sshd_config
+
+EXPOSE 22
+
+CMD /usr/sbin/sshd -D
+
+# 3. Create vagrant user
+RUN groupadd vagrant
+RUN useradd -d /home/vagrant -g vagrant -m -s /bin/bash vagrant
+RUN sudo sed -i '$a vagrant    ALL=(ALL) NOPASSWD: ALL' /etc/sudoers
+RUN echo vagrant:vagrant | chpasswd
+RUN sudo chown -R vagrant /home/vagrant
+
+# 4. Prepare directories for the project
+
+# Add project dir to docker
+
+ADD . /home/vagrant/demo
+WORKDIR /home/vagrant/demo
+
+EXPOSE 9292
+```
+
+Build docker image and run it:
 
 ```bash
-docker run -t -i ubuntu /bin/bash
+docker build -t demo demo
+docker run -d -p 42222:22 -p 9292:9292 --name demo demo
 ```
 
+As you can see, we map port 22 inside docker to port 42222 outside. It means that when we hit port 42222 with regular telnet tool, we'll hit service inside the docker.
+
+You can access virtual machine via ssh:
+
 ```bash
-docker build -t demo docker/demo
+ssh vagrant@192.168.59.103 -p 42222
 ```
 
+Now you can do your provision - it's exactly the same as with Vagrant example:
+
+```bash
+thor linux_install:prepare
+thor linux_install:rvm
+thor linux_install:ruby
+
+thor linux_install:postgres
+
+thor linux_install:postgres_create_user
+thor linux_install:postgres_create_schemas
+
+thor linux_install:project
+
+thor linux_install:rackup
+```
+
+After provisioning and starting server try to access your application from the browser:
+
 ```bash
-docker run -p 49160:8080 -d busybox
+open http://192.168.59.103:9292
 ```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+[VirtualBox]: https://www.virtualbox.org/wiki/Downloads
+[Vagrant]: http://www.vagrantup.com
+[boot2docker]: http://boot2docker.io
+[oracle_client_provision]:  https://github.com/shvets/oracle_client_provision
+[osx_provision]: https://github.com/shvets/osx_provision
+[sinatra]: http://www.sinatrarb.com

data/Vagrantfile

@@ -93,7 +93,7 @@ Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
   # the path on the guest to mount the folder. And the optional third
   # argument is a set of non-required options.
   # config.vm.synced_folder "../data", "/vagrant_data"
-  config.vm.synced_folder "../linux_provision/demo", "/home/vagrant/demo"
+  config.vm.synced_folder "demo", "/home/vagrant/demo"
 
   # Provider-specific configuration so you can fine-tune various
   # backing providers for Vagrant. These expose provider-specific options.
@@ -142,7 +142,7 @@ Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
   #
   # config.vm.provision "puppet" do |puppet|
   #   puppet.manifests_path = "manifests"
-  #   puppet.manifest_file  = "site.pp"
+  #   puppet.manifest_file  = "default.pp"
   # end
 
   # Enable provisioning with chef solo, specifying a cookbooks path, roles

data/demo/.ruby-version

@@ -1 +1 @@
-ruby-1.9.3
+1.9.3

data/lib/linux_provision/linux_provision_scripts.sh

@@ -72,52 +72,27 @@ sudo apt-get install -y postgresql
 
 sudo service postgresql restart
 
-
 #######################################
 [postgres_remote_access]
 
 sudo sed -i "s/#listen_addresses = 'localhost'/listen_addresses = '*'/g" /etc/postgresql/9.1/main/postgresql.conf
 sudo sed -i '$a host all all  0.0.0.0/0 md5' /etc/postgresql/9.1/main/pg_hba.conf
 
-
-#######################################
-[mysql]
-# Installs mysql server
-
-PATH=$PATH:/usr/local/bin
-
-MYSQL_USER='#{mysql.user}'
-MYSQL_PASSWORD='#{mysql.password}'
-MYSQL_SERVER_VERSION='5.5'
-
-sudo apt-get install -y libmysqlclient-dev ruby-dev
-
-sudo apt-get install debconf-utils
-sudo apt-get install -y mysql-client
-
-sudo debconf-set-selections <<< "mysql-server-$MYSQL_SERVER_VERSION mysql-server/root_password password $MYSQL_PASSWORD"
-sudo debconf-set-selections <<< "mysql-server-$MYSQL_SERVER_VERSION mysql-server/root_password_again password $MYSQL_PASSWORD"
-
-sudo apt-get -y install mysql-server
-
-sudo service mysql restart
-
-#sudo mysqladmin -u$MYSQL_USER password $MYSQL_PASSWORD
-
-
 #######################################
 [postgres_create_user]
+# Creates postgres user
 
 PATH=$PATH:/usr/local/bin
 
 APP_USER='#{postgres.app_user}'
 APP_PASSWORD='#{postgres.app_password}'
 
-sudo -u postgres psql -c "CREATE USER $APP_USER WITH PASSWORD '$APP_USER'"
+sudo -u postgres psql -c "CREATE USER $APP_USER WITH PASSWORD '$APP_PASSWORD'"
 
 
 #######################################
 [postgres_drop_user]
+# Drops postgres user
 
 PATH=$PATH:/usr/local/bin
 
@@ -128,6 +103,7 @@ sudo -u postgres psql -c "DROP USER $APP_USER"
 
 #######################################
 [postgres_create_schema]
+# Creates postgres schema
 
 SCHEMA='#{schema}'
 
@@ -142,6 +118,7 @@ sudo -u postgres psql -c "GRANT ALL PRIVILEGES ON DATABASE $SCHEMA to $APP_USER"
 
 #######################################
 [postgres_drop_schema]
+# Drops postgres schema
 
 PATH=$PATH:/usr/local/bin
 
@@ -149,9 +126,34 @@ SCHEMA='#{schema}'
 
 sudo -u postgres psql -c "DROP DATABASE $SCHEMA"
 
+#######################################
+[mysql]
+# Installs mysql server
+
+PATH=$PATH:/usr/local/bin
+
+MYSQL_USER='#{mysql.user}'
+MYSQL_PASSWORD='#{mysql.password}'
+MYSQL_SERVER_VERSION='5.5'
+
+sudo apt-get install -y libmysqlclient-dev ruby-dev
+
+sudo apt-get install debconf-utils
+sudo apt-get install -y mysql-client
+
+sudo debconf-set-selections <<< "mysql-server-$MYSQL_SERVER_VERSION mysql-server/root_password password $MYSQL_PASSWORD"
+sudo debconf-set-selections <<< "mysql-server-$MYSQL_SERVER_VERSION mysql-server/root_password_again password $MYSQL_PASSWORD"
+
+sudo apt-get -y install mysql-server
+
+sudo service mysql restart
+
+#sudo mysqladmin -u$MYSQL_USER password $MYSQL_PASSWORD
+
 
 #######################################
 [mysql_create_user]
+# Creates mysql user
 
 PATH=$PATH:/usr/local/bin
 
@@ -166,6 +168,7 @@ mysql -h $HOST_NAME -u$MYSQL_USER -p$MYSQL_PASSWORD -e "GRANT ALL PRIVILEGES ON
 
 #######################################
 [mysql_drop_user]
+# Drops mysql user
 
 APP_USER='#{mysql.app_user}'
 HOST_NAME='#{mysql.hostname}'
@@ -178,6 +181,7 @@ mysql -h $HOST_NAME  -u $MYSQL_USER -p"$MYSQL_PASSWORD" -e "DROP USER '$APP_USER
 
 #######################################
 [mysql_create_schema]
+# Creates mysql schema
 
 PATH=$PATH:/usr/local/bin
 
@@ -192,6 +196,7 @@ mysql -h $HOST_NAME -u$MYSQL_USER -p$MYSQL_PASSWORD -e "create database $SCHEMA;
 
 #######################################
 [mysql_drop_schema]
+# Drops mysql schema
 
 PATH=$PATH:/usr/local/bin
 

data/lib/linux_provision/version.rb

@@ -1,3 +1,3 @@
 class LinuxProvision
-  VERSION = "0.9.8"
+  VERSION = "0.9.10"
 end

data/presentation/virtualization/01-vagrant/slides.md

@@ -16,30 +16,30 @@
 * We are **working on multiple projects** on same workstation. As a result, suddenly your computer has "hidden",
 hard-to-discover inter-project dependencies or different versions of same library.
 
-* To overcome **It "works on my machine!"** syndrome - development environment is different from production environment.
+* To overcome **It works on my machine!** syndrome - development environment is different from production environment.
 
 * Sometimes required software is **not available** on developer's platform. Example: 64-bit instant client for oracle
-was broken for almost two years on OS/X >= 10.7.
+was broken for almost two years on OSX >= 10.7.
 
 * **Development for PAAS**, such as Heroku, Engine Yard etc. You can find/build virtualization that is pretty close to
 your platform.
 
 
-
 !SLIDE content transition=cover
 
 # Vagrant
 
 >
 
-![vagrant](vagrant.jpg)
+![vagrant](../images/vagrant.jpg)
 
 !SLIDE title-and-content transition=cover
 
 # What is it?
 
-* It is ruby gem.
-* it helps to provide easy to configure, reproducible, and portable work environments.
+* It is wrapper around virtual box.
+* It is an tool for managing virtual machines via a simple to use command line interface.
+* With vagrant you can work in a clean environment based on a standard template (base box).
 
 
 
@@ -50,23 +50,8 @@ your platform.
 * Install [VirtualBox](https://www.virtualbox.org/wiki/Downloads). Download it from dedicated web site and install
 it as native program. You can use it in UI mode, but it's not required.
 
-* Install [Vagrant](http://www.vagrantup.com) gem:
-
-```bash
-$ gem install vagrant
-```
-
-* or put it into **Gemfile**:
-
-```ruby
-gem "vagrant"
-```
-
-* Run bundler:
-
-```bash
-bundle install
-```
+* Install [Vagrant](http://www.vagrantup.com). Before it was distributed as ruby gem, now it's done as
+native application. Once installed, it will be accessible from command line as **vagrant** command.
 
 
 
@@ -252,7 +237,7 @@ vagrant ssh node2
 * It will have already preinstalled and configured ruby/rvm/mysql/postgres etc.:
 
 ```bash
-vagrant package --vagrantfile Vagrantfile --output proteus.box
+vagrant package --vagrantfile Vagrantfile --output new_linux_box.box
 ```
 
 
@@ -261,7 +246,8 @@ vagrant package --vagrantfile Vagrantfile --output proteus.box
 
 # What's next?
 
-* Once you install Vagrant with some provision (script, chef-solo or puppet), you can use it in same way as your worksation:
+* Once you install Vagrant with some provision (script, chef-solo or puppet), you can use it in same way
+as your workstation:
 
 ```bash
 vagrant ssh
@@ -275,10 +261,10 @@ rspec
 ASSET_HOST=http://22.22.22.22:3000 rails s
 ```
 
-* and then access it from the browser within [host computer](http://22.22.22.22:3000/triton):
+* and then access it from the browser within [host computer](http://22.22.22.22:3000/app):
 
 ```
-  open http://22.22.22.22:3000/triton
+  open http://22.22.22.22:3000/app
 ```
 
 

data/presentation/virtualization/02-provision/slides.md

@@ -40,7 +40,7 @@ unified, easy to replicate virtual platform with same characteristics for all de
 
 >
 
-![chef](chef.jpg)
+![chef](../images/chef.jpg)
 
 
 

data/presentation/virtualization/03-docker/slides.md

@@ -28,7 +28,7 @@ You can’t run a VM on top of another. You can run Docker on a VM because Docke
 
 ## How it works?
 
-* Docker needs to be run with root privelege.
+* Docker needs to be run with root privilege.
 
 Docker DOESN’T write into the image. Instead, it creates a layer with each Dockerfile line on top of the existing image, 
 which contains the modifications you made to the filesystem. Migrating from a previous state of filesystem to 

data/presentation/virtualization/showoff.json

@@ -15,9 +15,9 @@
     "lax_spacing": true
   },
   "sections": [
-//    {"section":"01-vagrant"},
-//    {"section":"02-provision"},
-    {"section":"03-docker"}
-//    {"section":"04-conclusion"}
+    {"section":"01-vagrant"},
+    {"section":"02-provision"},
+    {"section":"03-docker"},
+    {"section":"04-conclusion"}
   ]
 }

data/thor/linux_install.thor

@@ -28,22 +28,30 @@ class LinuxInstall < Thor
     # invoke :selenium
   end
 
-  desc "app", "Installs app"
-  def app
+  desc "create_env", "Installs environment"
+  def create_env
     invoke :postgres_create_user
     invoke :postgres_create_schemas
 
     invoke :mysql_create_user
     invoke :mysql_create_schemas
+  end
 
-    invoke :project
+  desc "delete_env", "Deletes environment"
+  def delete_env
+    invoke :postgres_drop_schemas
+    invoke :postgres_drop_user
+
+    invoke :mysql_drop_schemas
+    invoke :mysql_drop_user
   end
 
   desc "all", "Installs all required packages"
   def all
     invoke :general
     invoke :special
-    invoke :app
+    invoke :create_env
+    invoke :project
   end
 
   desc "postgres_create_schemas", "Initializes postgres schemas"

data/thor/showoff.thor

@@ -0,0 +1,15 @@
+$: << File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+require 'script_executor/executable'
+
+class Showoff < Thor
+  include Executable
+
+  desc "all", "Runs showoff"
+  def all
+    execute <<-CODE
+       cd presentation/virtualization
+       showoff serve
+    CODE
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: linux_provision
 version: !ruby/object:Gem::Version
-  version: 0.9.8
+  version: 0.9.10
 platform: ruby
 authors:
 - Alexander Shvets
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-02 00:00:00.000000000 Z
+date: 2014-09-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: text-interpolator
@@ -137,8 +137,6 @@ files:
 - demo/views/layout.erb
 - demo/views/new.erb
 - demo/views/note.erb
-- docker/postgres/Dockerfile
-- docker/postgres/bin/create_db.sh
 - lib/linux_provision.rb
 - lib/linux_provision/bin/selenium
 - lib/linux_provision/bin/xvfb
@@ -161,10 +159,10 @@ files:
 - spec/linux_install_spec.rb
 - spec/linux_provision_spec.rb
 - spec/spec_helper.rb
-- stats/viewstats.json
 - thor/demo_scripts.sh
 - thor/docker.thor
 - thor/linux_install.thor
+- thor/showoff.thor
 - thor/ssh.thor
 homepage: http://github.com/shvets/linux_provision
 licenses:

data/docker/postgres/Dockerfile

@@ -1,61 +0,0 @@
-# https://docs.docker.com/examples/postgresql_service/
-
-FROM ubuntu
-MAINTAINER SvenDowideit@docker.com
-
-# Add the PostgreSQL PGP key to verify their Debian packages.
-# It should be the same key as https://www.postgresql.org/media/keys/ACCC4CF8.asc
-RUN apt-key adv --keyserver keyserver.ubuntu.com --recv-keys B97B0AFCAA1A47F044F244A07FCC7D46ACCC4CF8
-
-# Add PostgreSQL's repository. It contains the most recent stable release
-#     of PostgreSQL, ``9.3``.
-RUN echo "deb http://apt.postgresql.org/pub/repos/apt/ precise-pgdg main" > /etc/apt/sources.list.d/pgdg.list
-
-# Update the Ubuntu and PostgreSQL repository indexes
-RUN apt-get update
-
-# Install ``python-software-properties``, ``software-properties-common`` and PostgreSQL 9.3
-#  There are some warnings (in red) that show up during the build. You can hide
-#  them by prefixing each apt-get statement with DEBIAN_FRONTEND=noninteractive
-RUN apt-get -y -q install python-software-properties software-properties-common
-RUN apt-get -y -q install postgresql-9.3 postgresql-client-9.3 postgresql-contrib-9.3
-
-# Note: The official Debian and Ubuntu images automatically ``apt-get clean``
-# after each ``apt-get``
-
-# Run the rest of the commands as the ``postgres`` user created by the ``postgres-9.3`` package when it was ``apt-get installed``
-USER postgres
-
-# Create a PostgreSQL role named ``docker`` with ``docker`` as the password and
-# then create a database `docker` owned by the ``docker`` role.
-# Note: here we use ``&&\`` to run commands one after the other - the ``\``
-#       allows the RUN command to span multiple lines.
-#RUN    /etc/init.d/postgresql start &&\
-#    psql --command "CREATE USER docker WITH SUPERUSER PASSWORD 'docker';" &&\
-#    createdb -O docker docker
-
-ADD bin/create_db.sh /src/
-RUN /src/create_db.sh
-
-
-# Adjust PostgreSQL configuration so that remote connections to the
-# database are possible.
-RUN echo "host all  all    0.0.0.0/0  md5" >> /etc/postgresql/9.3/main/pg_hba.conf
-
-# And add ``listen_addresses`` to ``/etc/postgresql/9.3/main/postgresql.conf``
-RUN echo "listen_addresses='*'" >> /etc/postgresql/9.3/main/postgresql.conf
-
-# Expose the PostgreSQL port
-EXPOSE 5432
-
-# Add VOLUMEs to allow backup of config, logs and databases
-VOLUME  ["/etc/postgresql", "/var/log/postgresql", "/var/lib/postgresql"]
-
-# Set the default command to run when starting the container
-CMD ["/usr/lib/postgresql/9.3/bin/postgres", "-D", "/var/lib/postgresql/9.3/main", "-c", "config_file=/etc/postgresql/9.3/main/postgresql.conf"]
-
-# docker stop postgres
-# docker rm postgres
-# docker build -t postgres docker/postgres
-# docker run -d -p 5432:5432 --name postgres postgres
-

data/docker/postgres/bin/create_db.sh

@@ -1,14 +0,0 @@
-#!/bin/sh
-
-/etc/init.d/postgresql start
-
-psql --command "CREATE USER ruby_dev WITH SUPERUSER PASSWORD 'ruby_dev';"
-
-createdb -O ruby_dev ruby_dev_test
-createdb -O ruby_dev ruby_dev_dev
-createdb -O ruby_dev ruby_dev_prod
-
-psql -l
-
-/etc/init.d/postgresql stop
-

data/stats/viewstats.json

@@ -1 +0,0 @@
-{}