dust-deploy 0.1.0

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+TODO

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in dust.gemspec
+gemspec

data/README.md

@@ -0,0 +1,154 @@
+dust - a ssh/facter only server deployment tool
+=============
+
+dust is a deployment tool, kinda like sprinkle. but cooler (at least for me).
+it's for those, who would like to maintain their servers with a tool like puppet or chef, but are scared by the thought of having configuration files, credentials and other stuff centrally on a server reachable via the internet.
+
+although the tool is not as versatile and elite as puppet, it's still cool for most use cases, and easily extendable.
+
+
+installing
+------------
+
+installation is quite simple. just 
+    gem install dust
+
+
+using
+------------
+
+first, let's start by creating your dust directory
+
+    $ mkdir mynetwork.dust
+
+then, create directories you might/will need. (there's going to be an automation process in the future, e.g. using "dust new mynetwork.dust")
+
+    $ cd mynetwork.dust
+    $ mkdir templates
+    $ mkdir nodes
+
+in the nodes directory, there will be your templates and node configurations.
+dust uses simple .yaml files for configuring your nodes.
+let's start by adding a simple host:
+
+    $ vi nodes/yourhost.yaml
+
+and put in basic information:
+
+    # the hostname (fqdn, or set the domain parameter as well, ip also works)
+    # you don't need a password if you connect using ssh keys
+    hostname: yourhost.example.com
+    password: supersecretphrase
+
+    # these are the default values, you have to put them in case you need something else.
+    # be aware: sudo usage is not yet supported, but ssh keys are!
+    port: 22
+    user: root
+
+    # because this alone won't tell dust what to do, let's for example install a package
+    recipes:
+      packages: [ 'vim', 'git-core', 'rsync' ]
+
+
+you can then save the file, and tell dust to get to work:
+
+    $ dust deploy
+
+    [ yourhost.example.com ]
+
+    |packages|
+     - checking if vim is installed [ ok ]
+     - checking if git-core is installed [ failed ]
+       - installing git-core [ ok ]
+     - checking if rsync is installed [ ok ]
+
+you should see dust connecting to the node, checking if the requestet packages are installed, and if not, install them.
+dust works with aptitude, yum and emerge systems at the moment (testet with ubuntu, debian, gentoo, scientificlinux, centos).
+feel free to contribute to dust, so that your system is also supportet. contribution is easy!
+
+
+inheritance
+------------
+
+because sometimes you will have similar configuration files for multiple systems, you can create templates.
+i usually start filenames of templates with an underscore, but that's not a must.
+
+    $ vi nodes/_default.yaml
+
+this template defines some general settings, usually used by most hosts
+
+    domain: example.com
+    port: 22
+    user: root
+
+
+and another one:
+
+    $ vi nodes/_debian.yaml
+
+in this template, i put in some debian specific settings
+
+    # you can add custom fields like "group"
+    # and filter on which hosts to deploy later
+    group: debian
+    
+    recipes:
+      locale: en_US.UTF-8
+      debsecan: default
+      repositories:
+        default:
+          url: "http://ftp.de.debian.org/debian/"
+          components: "main contrib non-free"
+    
+
+you can then inherit these templates in your yourhost.yaml:
+
+    hostname: yourhost
+    inherits: [ _default, _debian ]
+
+    recipes:
+      packages: [ 'vim', 'git-core', 'rsync' ]
+
+
+running dust now, will use the inherited settings as well.
+you can also overwrite settings in the template with the ones in yourhost.yaml
+
+    $ dust deploy
+
+    [ yourhost ]
+
+    |repositories|
+     - determining whether node uses apt [ ok ]
+     - deleting old repositories [ ok ]
+
+     - deploying default repository [ ok ]
+
+    |packages|
+     - checking if vim is installed [ ok ]
+     - checking if git-core is installed [ ok ]
+     - checking if rsync is installed [ ok ]
+
+    |locale|
+     - setting locale to 'en_US.UTF-8' [ ok ]
+
+    |debsecan|
+     - checking if debsecan is installed [ ok ]
+     - configuring debsecan [ ok ]
+
+
+
+
+using recipes (and their templates)
+------------
+
+
+writing your own recipes
+------------
+
+
+contributing
+------------
+
+you have a cool contribution or bugfix? yippie! just file in a pull-request!
+
+### the server.rb methods you can (and should!) use

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/dust

@@ -0,0 +1,215 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'thor/runner'
+require 'thor/util'
+require 'yaml'
+require 'dust'
+
+# stole this from rails
+# https://github.com/rails/rails/blob/c0262827cacc1baf16668af65c35a09138166394/activesupport/lib/active_support/core_ext/hash/deep_merge.rb
+class Hash
+  # Returns a new hash with +self+ and +other_hash+ merged recursively.
+  def deep_merge(other_hash)
+    dup.deep_merge!(other_hash)
+  end
+
+  # Returns a new hash with +self+ and +other_hash+ merged recursively.
+  # Modifies the receiver in place.
+  def deep_merge!(other_hash)
+    other_hash.each_pair do |k,v|
+      tv = self[k]
+      self[k] = tv.is_a?(Hash) && v.is_a?(Hash) ? tv.deep_merge(v) : v
+    end
+    self
+  end
+end
+
+# stole this from Afz902k who posted something similar at stackoverflow.com
+# adds ability to check if a class with the name of a string exists
+class String
+    def to_class
+        Kernel.const_get self.capitalize
+    rescue NameError 
+        nil
+    end
+
+    def is_a_defined_class?
+        true if self.to_class
+    rescue NameError
+        false
+    end
+end
+
+
+module  Dust
+  class Deploy < Thor::Runner
+
+    default_task :deploy
+
+    desc 'deploy [server.yaml] [--filter key=value,value2] [--recipes recipe1 recipe2] [--proxy host:port]',
+         'deploy all recipes to the node(s) specified in server.yaml or to all nodes defined in ./nodes/'
+
+    method_options :filter => :hash, :recipes => :array, :proxy => :string,
+                   :restart => :boolean, :reload => :boolean
+
+    def deploy yaml=''
+      initialize_thorfiles
+      Dust.print_failed 'no servers match this filter' if load_servers(yaml).empty?
+
+      run_recipes 'deploy'
+    end
+
+
+    desc 'status [server.yaml] [--filter key=value,value2] [--recipes recipe1 recipe2] [--proxy host:port]',
+         'display status of recipes specified by filter'
+
+    method_options :filter => :hash, :recipes => :array, :proxy => :string
+
+    def status yaml=''
+      initialize_thorfiles
+      Dust.print_failed 'no servers match this filter' if load_servers(yaml).empty?
+
+      run_recipes 'status'
+    end
+
+
+    private
+
+    # run specified recipes in the given context
+    def run_recipes context
+      @nodes.each do |node|
+        recipes =  {}
+
+         # skip this node if there are no recipes found
+        next unless node['recipes']
+
+        # generate list of recipes for this node
+        node['recipes'].each do |recipe, ingredients|
+
+          # in case --recipes was set, skip unwanted recipes
+          next unless options[:recipes].include?(recipe) if options[:recipes]
+
+          # skip disabled recipes
+          next if ingredients == 'disabled'
+
+          # check if method and thor task actually exist
+          k = Thor::Util.find_by_namespace recipe
+          next unless k
+          next unless k.method_defined? context
+
+          recipes[recipe] = ingredients
+        end
+
+        # skip this node unless we're actually having recipes to cook
+        next if recipes.empty?
+
+
+        # connect to server
+        server = Server.new node
+        next unless server.connect
+
+        # runs the method with the recipe name, defined and included in recipe/*.rb
+        # call recipes for each recipe that is defined for this node
+        recipes.each do |recipe, ingredients|
+          send recipe, context, server, ingredients, options
+          puts
+        end
+
+        server.disconnect
+      end
+    end
+
+    # overwrite thorfiles to look for tasks in the recipes directories
+    def thorfiles(relevant_to=nil, skip_lookup=false)
+      Dir[File.dirname(__FILE__) + '/../lib/dust/recipes/*.rb'] | Dir['recipes/*.rb']
+    end
+
+    # loads servers
+    def load_servers yaml=''
+      @nodes = []
+
+      # if the argument is empty, load all yaml files in the ./nodes/ directory
+      # if the argument is a directory, load yaml files in this directory
+      # if the argument is a file, load the file.
+      if yaml.empty?
+        yaml_files = Dir['./nodes/**/*.yaml']
+      else
+        yaml_files = Dir["#{yaml}/**/*.yaml"] if File.directory? yaml
+        yaml_files = yaml if File.exists? yaml
+      end
+
+      unless yaml_files
+        Dust.print_failed "#{yaml} doesn't exist. exiting."
+        exit
+      end
+
+      yaml_files.each do |file|
+        node = YAML.load_file(file)
+
+        # if the file is empty, just skip it
+        next unless node
+
+        # if there is not hostname field in the yaml file,
+        # treat this node file as a template, and skip to the next one
+        next unless node['hostname']
+  
+        # look for the inherits field in the yaml file,
+        # and merge the templates recursively into this node
+        if node['inherits']
+          inherited = {}
+          node.delete('inherits').each do |file|
+            template = YAML.load_file "./nodes/#{file}.yaml"
+            inherited.deep_merge! template
+          end
+          node = inherited.deep_merge node
+        end
+
+        # if more than one hostname is specified, create a node
+        # with the same settings for each hostname
+        node['hostname'].each do |hostname|
+          n = node.clone
+
+          # overwrite hostname with single hostname (in case there are multiple)
+          n['hostname'] = hostname
+
+          # create a new field with the fully qualified domain name
+          n['fqdn'] = hostname
+          n['fqdn'] += '.' + n['domain'] if n['domain']
+
+          # pass command line proxy option
+          n['proxy'] = options[:proxy] if options[:proxy]
+
+          # add this node to the global node array
+          @nodes.push n unless filtered? n
+        end
+      end
+    end
+
+    # checks if this node was filtered out by command line argument
+    # e.g. --filter environment:staging filters out all machines but
+    # those in the environment staging
+    def filtered? node
+
+      # if filter is not specified, instantly return false
+      return false unless options[:filter]
+
+      # remove items if other filter arguments don't match
+      options[:filter].each do |k, v|
+        next unless v # skip empty filters
+
+        # filter if this node doesn't even have the attribute
+        return true unless node[k]
+
+        # allow multiple filters of the same type, divided by ','
+        # e.g. --filter environment:staging,production
+        return true unless v.split(',').include? node[k]
+      end
+
+      # no filter matched, so this host is not filtered.
+      false
+    end
+  end
+
+  Deploy.start
+end

data/dust.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "dust/version"
+
+Gem::Specification.new do |s|
+  s.name        = "dust-deploy"
+  s.version     = Dust::VERSION
+  s.authors     = ["kris kechagia"]
+  s.email       = ["kk@rndsec.net"]
+  s.homepage    = ""
+  s.summary     = %q{small server deployment tool for complex environments}
+  s.description = %q{when puppet and chef suck because you want to be in control and sprinkle just cannot to enough for you}
+
+  s.rubyforge_project = "dust-deploy"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+  s.add_runtime_dependency 'net-ssh'
+  s.add_runtime_dependency 'net-scp'
+  s.add_runtime_dependency 'net-sftp'
+  s.add_runtime_dependency 'thor'
+end

data/lib/dust.rb

@@ -0,0 +1,6 @@
+require 'dust/print_status'
+require 'dust/convert_size'
+require 'dust/server'
+
+module Dust
+end

data/lib/dust/convert_size.rb

@@ -0,0 +1,21 @@
+module Dust
+
+  # converts string to kilobytes (rounded)
+  def self.convert_size s
+    i, unit = s.split(' ')
+
+    case unit.downcase
+    when 'kb'
+      return i.to_i
+    when 'mb'
+      return (i.to_f * 1024).to_i
+    when 'gb'
+      return (i.to_f * 1024 * 1024).to_i
+    when 'tb'
+      return (i.to_f * 1024 * 1024 * 1024).to_i
+    else
+      return false
+    end
+  end
+
+end

data/lib/dust/print_status.rb

@@ -0,0 +1,57 @@
+module Dust
+  # colors for terminal
+  def self.red thick=1;      "\033[#{thick};31m"; end
+  def self.green thick=1;    "\033[#{thick};32m"; end
+  def self.yellow thick=1;   "\033[#{thick};33m"; end
+  def self.blue thick=1;     "\033[#{thick};34m"; end
+  def self.pink thick=1;     "\033[#{thick};35m"; end
+  def self.turquois thick=1; "\033[#{thick};36m"; end
+  def self.grey thick=1;     "\033[#{thick};37m"; end
+  def self.black thick=1;    "\033[#{thick};38m"; end
+  def self.none;             "\033[0m"; end
+
+  $stdout.sync = true # autoflush
+
+  def self.print_result ret, quiet=false
+    if ret == 0 or ret == true
+      print_ok unless quiet
+      return true
+    else
+      print_failed unless quiet
+      return false
+    end
+  end
+
+  def self.print_ok string="", level=0
+    print_msg "#{string} #{blue}[ ok ]#{none}\n", level
+  end
+
+  def self.print_failed string="", level=0
+    print_msg "#{string} #{red}[ failed ]#{none}\n", level
+  end
+
+  def self.print_warning string="", level=0
+    print_msg "#{string} #{yellow}[ warning ]#{none}\n", level
+  end
+
+  def self.print_hostname hostname, level=0
+    print_msg "\n[ #{blue}#{hostname}#{none} ]\n\n", level
+  end
+
+  def self.print_recipe recipe, level=0
+    print_msg "#{green}|#{recipe}|#{none}\n", level
+  end
+
+  # indent according to level
+  # level 0
+  #  - level 1
+  #    - level 2
+  def self.print_msg string, level=1
+    if level == 0
+      print string
+    else
+      print ' ' + '  ' * (level - 1) + '- ' + string
+    end
+  end
+
+end