vito 0.0.2 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 273dc6976a1c63197a0576ebe4ef79ec7270c0ed
-  data.tar.gz: 01c117e4e67876913b201ca883bdcef79eb536a4
+  metadata.gz: 24b73b5ceaa70f360c97d0bb28e4d2ca8a9d8e1d
+  data.tar.gz: 2759c1d3f37d0994c6b1b271d9093a7e93db92c1
 SHA512:
-  metadata.gz: c406ea381b7ae439ff5bac7670a67381e7f95382189a685882bef8c819e6f04291eb00bde33d17e37f439dc8f346ede010e1685496fabbe384057e2d2aacabcd
-  data.tar.gz: e722b05a007fd7d19f59fa45b528bace134d56d73bdca3a3ed447d99f830310ca5c8c9b19cd2b9e721ed53ff41dbd260cc9b9497b415632ef9b41363e7ebba12
+  metadata.gz: 5fea002c81b1e578fcd42a913f594211a32d5414964d746f0af45a2d147b45f54445979d0a8c7f119debee9bacfbbd16a6831a03d19564c622916ef6ddfd3c10
+  data.tar.gz: 88ba9d0cc04185a0983bf31c76859ad9a3509b0570d0cb08e2e6d055b2ab145928cb2cce91b26d8d18409776176e635f7ab54117a1ea43d1e3f518545623c77f

data/.gitignore

@@ -17,3 +17,4 @@ test/version_tmp
 tmp
 .vagrant/
 .vagrant*
+.DS_Store

data/.rvmrc

@@ -0,0 +1 @@
+rvm --create use "ruby-2.0.0-p0@vito"

data/README.md

@@ -37,16 +37,42 @@ For now, it won't be hosted, just sending SSH messages instead.
 
 These are the packages that are currently working:
 
-rbenv, git, ruby
+rbenv, git, ruby, postgres
 
 ## Usage
 
-Vito is not read for production yet.
+Vito currently works only in development.
+
+## Documentation
+
+[Read the documentation](http://github.com/kurko/vito/blob/master/docs/manual.md)
 
 ## 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
+Integration tests are run with Vagrant, you have to install it first. **Important**:
+don't use the gem, but the newer packaged installation. In fact, you should
+uninstall it (removing binstubs even) or Bundler will start complaining.
+
+Once you clone the repo, run:
+
+```bash
+$ rake setup:download_vagrant_box
+```
+
+This will download a VirtualBox image, initialize it with Vagrant and take a
+initial snapshot. Whenever you run a spec, we'll roll back to this snapshot
+to test it in a clean slate.
+
+Add recipes to the `recipes/` dir. You can base your recipe on the existing ones.
+
+Also, take a look at the rake tasks for running specs, e.g `rake spec:unit`,
+`rake spec:acceptance`, `rake spec:all` etc
+
+Once you're ready to push:
+
+1. Fork the repo
+3. Create your feature branch (`git checkout -b my-new-feature`)
+4. Commit your changes (`git commit -am 'Added some feature'`)
+5. Run specs with `rake spec:all` (check `rake -T` for more options)
+6. Push to the branch (`git push origin my-new-feature`)
+7. Create new Pull Request

data/Rakefile

@@ -1,6 +1,14 @@
 #!/usr/bin/env rake
 require "bundler/gem_tasks"
 
+def take_snapshot(name = "vito_snapshot")
+  puts "Installing vagrant-vbox-snapshot to take a snapshot"
+  system "vagrant plugin install vagrant-vbox-snapshot"
+
+  puts "Taking a snapshot of the current vm state"
+  system "vagrant snapshot take #{name}"
+end
+
 desc "Sets up a Vagrant box for running specs"
 namespace :setup do
   task :download_vagrant_box do
@@ -9,5 +17,32 @@ namespace :setup do
     system "vagrant box add ubuntu_spec_box http://puppet-vagrant-boxes.puppetlabs.com/ubuntu-server-12042-x64-vbox4210-nocm.box"
     puts "Initializing box with Vagrant"
     system "vagrant init ubuntu_spec_box"
+    take_snapshot("initial_box")
   end
 end
+
+namespace :vagrant do
+  desc "Creates a snapshot of the current box state to be used in specs"
+  task :take_snapshot do
+    take_snapshot("initial_box")
+  end
+end
+
+namespace :spec do
+  desc "Runs all specs"
+  task all: ["spec:unit", "spec:acceptance"]
+
+  desc "Runs specs by setting up a Vagrant box and installing recipes in it (could take minutes)"
+  task :acceptance do
+    puts "Running spec using Vagrant boxes (this could take several minutes)"
+    system "bundle exec rspec spec/acceptance"
+  end
+
+  desc "Runs unit specs (no Vagrant box required)"
+  task :unit do
+    puts "Running unit specs"
+    system "bundle exec rspec spec/vito"
+  end
+end
+
+task default: ["spec:unit"]

data/Vagrantfile

@@ -29,7 +29,7 @@ Vagrant::Config.run do |config|
 
   # Forward a port from the guest to the host, which allows for outside
   # computers to access the VM, whereas host only networking does not.
-  config.vm.forward_port 23, 22
+  # config.vm.forward_port 23, 22
 
   # Share an additional folder to the guest VM. The first argument is
   # an identifier, the second is the path on the guest to mount the

data/bin/vito

@@ -1,7 +1,12 @@
 #!/usr/bin/env ruby
 
-$LOAD_PATH.unshift File.expand_path('../../', __FILE__)
-require "lib/vito"
+# Doing this so we can run the following in development (which doesn't have
+# lib/ in the path)
+#
+#   $ ./bin/vito
+#
+$LOAD_PATH.unshift File.expand_path('../../lib/', __FILE__)
+require "vito"
 
 shell = Vito::ShellInitializer.new(ARGV)
 shell.run

data/docs/manual.md

@@ -0,0 +1,79 @@
+_Atention: At this moment, this guide is our roadmap, not the actual manual._
+
+## API guide
+
+**Vito** uses a recipes file called `vito.rb` to determine what servers should
+be installed. The `vito.rb` defines servers and theirs programs. An example:
+
+```ruby
+server :linode do
+  # Vagrant box
+  connection :ssh, command: "ssh -i ~/.vagrant.d/insecure_private_key vagrant@localhost -p2222"
+
+  install :rbenv
+  install :git
+  install :ruby, version: "1.9.3-p125"
+  install :postgres
+  install :tmux
+  install :ruby_gem, :bundler
+  install :passenger
+end
+```
+
+Here, we define the connection to the server and what should be installed in it.
+
+## Getting started
+
+Install Vito with
+
+`$ gem install vito`
+
+## Command-line
+
+The following command will run Vito and try to load `vito.rb` file from the
+current path.
+
+`$ vito`
+
+You can also define a particular file with
+
+`$ vito my_file.rb`
+
+Run `vito help` to see the available options you have.
+
+## The `vito.rb` file
+
+### connection(type, options)
+
+Defines the connection to the server. The possible types are:
+
+**ssh:** the server will be accessed via SSH. The possible options are:
+
+* `command`: when you want to specify just a prefix, such as
+`ssh deploy@12.34.56.78` or `vagrant ssh -c`. If you used the last, Vito would
+send a command such as `vagrant ssh -c "rbenv install 1.9.3-p125"`. When
+defining a command, you don't need to define other options (because the username
+and host will already be included).
+* `username`: if you define a username, you have to define a host.
+* `host`
+* `port`: defaults to 22
+* `key`: path to file containing public key needed for the connection
+
+**local:** when the server is the machine Vito is already running.
+
+### install(program, options = {}, &block)
+
+Defines what program should be installed. For a list of available programs, type
+
+`$ vito programs`
+
+Some programs accept blocks, such as `passenger` (allows you to use Rails with
+Apache or nginx):
+
+```ruby
+install :passenger do
+  with :apache
+  # will open port 80, plus 443
+  vhosts_for :rails, with: :ssl, path: "/var/www/my_app/public"
+end
+```

data/lib/samples/vito_for_rails.rb

@@ -0,0 +1,14 @@
+server :rails_server do
+  connection :ssh, user: "deploy", host: "0.0.0.0"
+
+  install :rbenv
+  install :git
+  install :ruby, version: "1.9.3-p125"
+  install :postgres
+  install :tmux
+  install :passenger do
+    with :apache
+    # will open port 80, plus 443
+    vhosts_for :rails, with: :ssl, path: "/var/www/my_app/public"
+  end
+end

data/lib/vito.rb

@@ -5,5 +5,5 @@ require "active_support/inflector"
 module Vito
 end
 
-Dir["lib/vito/**/*.rb"].each { |f| require f }
-
+current_path = File.expand_path("../", __FILE__)
+Dir["#{current_path}/vito/**/*.rb"].each { |f| require f }

data/lib/vito/connection.rb

@@ -5,6 +5,8 @@ module Vito
     def initialize(type, args = {})
       @options = {}
       @options[:command] = args[:command]
+      @options[:verbose] = args[:verbose] || false
+      @options[:silent]  = args[:silent]  || false
     end
 
     def query(command)
@@ -14,48 +16,39 @@ module Vito
 
     def run(command)
       command = final_command(command)
-      Log.write "* Executing: #{command}"
+      Log.write("* Executing: #{command}") unless silent?
       output = execute_command(command)
 
+      Log.write(output.result, verbose?)
       unless output.success?
-        Log.write "An error occurred. Here's the stacktrace:"
-        Log.write output.result
-        Log.write ""
+        Log.raise "An error occurred. Here's the stacktrace:"
+        Log.raise output.result
+        Log.raise ""
+        raise "Error."
       end
 
       output
     end
 
-    class Output
-      def initialize(stdin, stdout, stderr, thread)
-        @stdout = stdout
-        @stderr = stderr
-        @thread = thread.value
-      end
+    private
 
-      def success?
-        @thread.exitstatus == 0
-      end
+    attr_reader :options
 
-      def result
-        if success?
-          @stdout.read
-        else
-          @stderr.read
-        end
-      end
+    def verbose?
+      @options[:verbose]
     end
 
-    private
-
-    attr_reader :options
+    def silent?
+      @options[:silent]
+    end
 
     def execute_command(command)
       stdin, stdout, stderr, thread = []
-      Bundler.with_clean_env do
-        stdin, stdout, stderr, thread = Open3.popen3(command)
-      end
-      Output.new(stdin, stdout, stderr, thread)
+      # In case we're in development and running `vagrant ssh -c`
+      #Bundler.with_clean_env do
+      stdin, stdout, stderr, thread = Open3.popen3(command)
+      #end
+      Vito::ConnectionOutput.new(stdin, stdout, stderr, thread)
     end
 
     def final_command(command)

data/lib/vito/dsl/installation.rb

@@ -0,0 +1,15 @@
+module Vito
+  module Dsl
+    class Installation
+      def initialize(name, options, connection)
+        @name = name.to_s
+        @options = options
+        @connection = connection
+      end
+
+      def install
+        "Vito::Recipes::#{@name.camelize}".constantize.new(@options, @connection).run
+      end
+    end
+  end
+end

data/lib/vito/dsl/server.rb

@@ -0,0 +1,17 @@
+module Vito
+  module Dsl
+    class Server
+      def initialize(args = nil)
+        @args = args
+      end
+
+      def connection(type, options = {})
+        @connection ||= Vito::Connection.new(type, options)
+      end
+
+      def install(name, options = {})
+        Vito::Dsl::Installation.new(name, options, @connection).install
+      end
+    end
+  end
+end

data/lib/vito/dsl_file.rb

@@ -0,0 +1,24 @@
+module Vito
+  class DslFile
+    def initialize(argv = nil)
+      @argv = argv
+    end
+
+    def run(code_string = nil, &block)
+      if block_given?
+        instance_eval(&block)
+      else
+        instance_eval(code_string)
+      end
+    end
+
+    private
+
+    attr_reader :options
+
+    # called by the vito.rb file
+    def server(*args, &block)
+      Vito::Dsl::Server.new(args).instance_eval(&block)
+    end
+  end
+end

data/lib/vito/log.rb

@@ -1,6 +1,12 @@
 module Vito
   class Log
-    def self.write(string)
+    def self.write(string, output_to_stdout = true)
+      if ENV["env"] != "test"
+        puts string if output_to_stdout
+      end
+    end
+
+    def self.raise(string)
       puts string
     end
 

data/lib/vito/operating_system.rb

@@ -4,18 +4,8 @@ module Vito
       @connection = connection
     end
 
-    def update_packages
-      os.update_packages
-    end
-
-    def install_dependencies(dependencies)
-      os.install_dependencies(dependencies)
-    end
-
-    private
-
     def os
-      @os ||= Vito::OperatingSystem::Ubuntu10.new(@connection)
+      @os ||= Vito::OperatingSystems::Ubuntu10.new(@connection)
     end
   end
 end

data/lib/vito/operating_systems/ubuntu_10.rb

@@ -0,0 +1,31 @@
+module Vito
+  module OperatingSystems
+    class Ubuntu10
+      NAME = :ubuntu
+      VERSION = "10"
+
+      def initialize(connection)
+        @connection = connection
+      end
+
+      def is?(name, version = nil)
+        version = VERSION unless version
+        name == NAME && version.to_s == VERSION
+      end
+
+      def update_packages
+        @connection.run("sudo apt-get update")
+      end
+
+      def install_dependencies(dependencies)
+        @connection.run("sudo apt-get install -y #{dependencies.join(" ")}")
+      end
+
+      private
+
+      def version
+        10
+      end
+    end
+  end
+end