puppi 0.0.1alpha

data/.autotest

@@ -0,0 +1,54 @@
+require 'autotest'
+
+Autotest.add_hook :initialize do |at|
+  at.clear_mappings
+  # watch out for Ruby bug (1.8.6): %r(/) != /\//
+  at.add_mapping(%r%^spec/.*_spec\.rb$%) { |filename, _|
+    filename
+  }
+  at.add_mapping(%r%^lib/(.*)\.rb$%) { |_, m|
+    ["spec/#{m[1]}_spec.rb"]
+  }
+  at.add_mapping(%r%^spec/(spec_helper|shared/.*)\.rb$%) {
+    at.files_matching %r%^spec/.*_spec\.rb$%
+  }
+end
+
+class RspecCommandError < StandardError; end
+
+class Autotest::Rspec < Autotest
+  
+  SPEC_PROGRAM = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'bin', 'spec'))
+
+  def initialize
+    super
+    self.failed_results_re = /^\d+\)\n(?:\e\[\d*m)?(?:.*?in )?'([^\n]*)'(?: FAILED)?(?:\e\[\d*m)?\n\n?(.*?(\n\n\(.*?)?)\n\n/m
+    self.completed_re = /\n(?:\e\[\d*m)?\d* examples?/m
+  end
+
+  def consolidate_failures(failed)
+    filters = new_hash_of_arrays
+    failed.each do |spec, trace|
+      if trace =~ /\n(\.\/)?(.*spec\.rb):[\d]+:/
+        filters[$2] << spec
+      end
+    end
+    return filters
+  end
+
+  def make_test_cmd(files_to_test)
+    files_to_test.empty? ? '' :
+      "#{ruby} #{SPEC_PROGRAM} --autospec #{normalize(files_to_test).keys.flatten.join(' ')} #{add_options_if_present}"
+  end
+
+  def normalize(files_to_test)
+    files_to_test.keys.inject({}) do |result, filename|
+      result[File.expand_path(filename)] = []
+      result
+    end
+  end
+
+  def add_options_if_present # :nodoc:
+    File.exist?("spec/spec.opts") ? "-O #{File.join('spec','spec.opts')} " : ""
+  end
+end

data/.gitignore

@@ -0,0 +1,7 @@
+.DS_Store
+coverage/
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+tmp/

data/.rvmrc

@@ -0,0 +1 @@
+rvm use ruby-1.9.3

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - jruby-18mode # JRuby in 1.8 mode
+  - jruby-19mode # JRuby in 1.9 mode
+  - rbx-18mode
+  - rbx-19mode
+# uncomment this line if your project needs to run something other than `rake`:
+script: RUN_ENV=TEST bundle exec rspec spec

data/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+
+gem 'mail'
+gem 'rake'
+
+group :test do
+  gem 'autotest'
+  gem 'rspec'
+  gem 'fakefs'
+  gem 'simplecov'
+end
+
+# Specify your gem's dependencies in puppi-ruby.gemspec
+gemspec

data/README.rdoc

@@ -0,0 +1,51 @@
+= Puppi on Ruby
+
+This is an experimental version of Puppi made in Ruby
+It's supposed to replace the existing puppi command written in bash.
+
+
+== README (DRIVEN DEVELOPMENT)
+
+        puppi <action> <project_name> [ -options ]
+
+The puppi command has these possibile actions:
+
+* [ puppi init project_name ] : First time initialization of the defined project
+
+* [ puppi deploy project_name ] : Deploys the defined project
+
+* [ puppi rollback project_name ] : Rollback to a previous deploy state 
+
+* [ puppi check ] : Runs project specific and host wide checks 
+
+* [ puppi log ] : Tails system wide or project specific logs 
+
+* [ puppi info topic_name ] : Show system information (for all or only the specified topic)
+
+* [ puppi todo ] : Show things to do (or done) manually on the system
+
+And these options:
+
+* -f - Force puppi commands execution flow also on CRITICAL errors
+
+* -i - Interactively ask confirmation for every step
+
+* -t - Test mode. Just show the commands that should be executed
+
+* -d <yes|full> - Debug mode. Show debug of what is done.
+
+* -r <yes|no|fail> - Enable reporting: yes/no/only on failures. Default depends on action
+
+* -s <yes|no|fail> - Show output: yes/no/only for failures. Default: yes
+
+* -g <pattern> - Grep command output with the selected pattern
+
+* -o "parameter=value parameter2=value2" - Set manual options to override defaults
+
+
+=== Files and directories
+
+* /etc/puppi/data (datadir) contains one yaml file for each Puppet class or defines that uses the puppi::ze define. 
+This yaml contains all the variables provided by the class / define and has this naming layout:
+helper_module.yaml. Where helper is the name of the helper file to use to manage the variables provided in the file and module is the name of the module or class or define that has created the yaml via puppi::ze
+* /etc/puppi/helpers contains the helpers file (created by puppi::helper): a Yaml that describes, for each puppi action, what commands to run and the names of the variables to use (as named in the /etc/puppi/data/helper_module.yaml files) 

data/Rakefile

@@ -0,0 +1,4 @@
+require "rspec/core/rake_task"
+require "bundler/gem_tasks"
+
+RSpec::Core::RakeTask.new

data/autotest/discover.rb

@@ -0,0 +1 @@
+Autotest.add_discovery { "rspec2" }

data/bin/puppi

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+require "optparse"
+require 'puppi'
+Puppi::initial_checks
+
+begin
+  options = Hash.new
+  OptionParser.new do |opts|
+    opts.banner = "Usage: " + File.basename($0) + " [options] ..."
+
+    options[:action] = false
+    opts.on( "-a", "--action action", String, "action to perform" ) do |action|
+      options[:action] = action
+    end
+    options[:puppi_module] = nil
+    opts.on( "-m", "--module module", String, "module name to act on (Optional)" ) do |puppi_module|
+      options[:puppi_module] = puppi_module
+    end
+    options[:notification] = Array.new
+    opts.on( "-n", "--notification notification1,notification2", Array, "notification(s) methods (Optional)" ) do |notification|
+      options[:notification] = notification
+    end
+    opts.on_tail("-h", "--help", "Show this message") do
+      puts opts
+    end
+  end.parse!
+rescue OptionParser::MissingArgument => e
+  warn "You can't specify an option without any argumento ("+e.to_s+")"
+  exit 1
+end
+
+if options.values.uniq == [false]
+  warn "Use -h, --help for usage."
+  exit 1
+end
+
+if options[:action] == false
+  warn "You MUST specify an action"
+  warn "Use -h, --help for usage."
+  exit 1
+end
+
+output = Puppi::Action.new(options).output
+Puppi::Notification.new(options[:notification], output)

data/etc/data/standard_openssh.yaml

@@ -0,0 +1,59 @@
+--- 
+  name: openssh
+  config_file_mode: "0644"
+  puppi_helper: standard
+  monitor_tool: puppi nagios munin
+  manage_file: present
+  manage_monitor: true
+  source_dir_purge: false
+  bool_debug: false
+  title: openssh
+  data_dir: /etc/ssh
+  config_file_init: /etc/sysconfig/sshd
+  firewall: false
+  source_dir: ""
+  caller_module_name: openssh
+  port: "22"
+  log_file: /var/log/messages
+  service: sshd
+  firewall_tool: ""
+  bool_firewall: false
+  protocol: tcp
+  config_file_owner: root
+  process: sshd
+  puppi: "true"
+  monitor_target: 0.0.0.0
+  manage_file_replace: true
+  config_file_group: root
+  process_user: root
+  firewall_src: 0.0.0.0/0
+  bool_absent: false
+  manage_package: present
+  service_status: true
+  package: openssh-server
+  monitor: "yes"
+  disableboot: false
+  template: ""
+  manage_service_ensure: running
+  manage_firewall: true
+  config_file: /etc/ssh/sshd_config
+  config_dir: /etc/ssh
+  bool_disableboot: false
+  bool_monitor: true
+  bool_audit_only: false
+  module_name: openssh
+  process_args: ""
+  debug: "no"
+  disable: false
+  bool_disable: false
+  bool_puppi: true
+  log_dir: /var/log
+  pid_file: /var/run/sshd.pid
+  audit_only: false
+  absent: false
+  source: ""
+  my_class: ""
+  manage_service_enable: true
+  firewall_dst: 10.42.20.10
+  options: ""
+  bool_source_dir_purge: false

data/etc/helpers/standard.yaml

@@ -0,0 +1,13 @@
+--- 
+:info: 
+  -
+    :command: "rpm -qi $package_name"
+    :description: "show package info"
+  -
+    :command: "service $service_name"
+    :description: "show service info"
+:check:
+  -
+    :command: "chk_port $port"
+    :description: "checks port"
+

data/etc/t.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'pry'
+require File.dirname(__FILE__) + '/lib/puppi'
+
+require 'puppi'
+
+binding.pry

data/lib/puppi.rb

@@ -0,0 +1,34 @@
+module Puppi
+  require 'fileutils'
+  require 'puppi/files/datafile'
+  require 'puppi/files/helper'
+  require 'puppi/files/notification'
+  require 'puppi/action'
+  require 'puppi/generate_sample_data'
+  require 'puppi/loader'
+  require 'puppi/notification'
+  require 'puppi/notifications/mail'
+  require 'puppi/notifications/stdout'
+  require 'puppi/version'
+  require 'yaml'
+  
+  if ENV["RUN_ENV"] == "TEST"
+    @@puppidir = File.dirname(File.dirname(__FILE__))+"/tmp/config"
+  else
+    @@puppidir = "/etc/puppi"
+  end
+  
+  class << self
+    def puppidir
+      @@puppidir
+    end
+    
+    def initial_checks
+      directories = %w[ data helpers notifications ]
+      directories.each do |directory|
+        FileUtils.mkdir_p @@puppidir+'/'+directory
+        raise "Puppi::NoPuppiDir" unless File.directory?(puppidir+'/'+directory)
+      end
+    end
+  end
+end

data/lib/puppi/action.rb

@@ -0,0 +1,50 @@
+module Puppi
+  class Action
+    attr_reader :puppi_module, :output
+    
+    def initialize (options)
+      @loader = Puppi::Loader.new
+      @actions = [ 'check', 'log', 'info' ]
+      if options[:puppi_module].nil?
+        @puppi_module = nil
+      else
+        @puppi_module = options[:puppi_module].to_s
+      end
+      if @actions.include? options[:action].to_s
+        execute options[:action].to_s
+      else
+        raise "No Action Found"
+      end
+    end
+    
+    def execute action
+      @datafiles = @loader.load_all('data', @puppi_module)
+      @output = Array.new
+      @datafiles.each do |datafile|
+        @loaded_datafile = @loader.load_datafile(datafile)
+        datafile_helper = datafile.split("_")[0]
+        module_helper = datafile.split("_")[1]
+        @helper_commands = @loader.load_helperfile datafile_helper, action
+        return nil unless not @helper_commands.nil?
+        @helper_commands.each do |command|
+          @output << (run_command command, module_helper)
+        end
+      end
+    end
+    
+    private
+    def run_command command, module_helper
+      @running_command = prepare_command command.command
+      output = IO.popen(@running_command, :err => [:child, :out]) unless @running_command.nil?
+      output.nil? ? nil : output.read
+    end
+    
+    def prepare_command command
+      begin
+        command % @loaded_datafile.variables
+      rescue KeyError
+        nil
+      end 
+    end
+  end
+end

data/lib/puppi/files/datafile.rb

@@ -0,0 +1,16 @@
+module Puppi
+  module Files
+    class Datafile
+      attr_reader :variables
+    
+      def initialize args = {}
+        @variables = args
+        @var = Hash.new
+        @variables.each_key do |key|
+          @var[key.to_sym] = @variables[key]
+        end
+        @variables = @var
+      end
+    end
+  end
+end

data/lib/puppi/files/helper.rb

@@ -0,0 +1,12 @@
+module Puppi
+  module Files
+    class Helper
+      attr_reader :command, :description
+
+      def initialize args = {}
+        @command     = args[:command]
+        @description = args[:description]
+      end
+    end
+  end
+end

data/lib/puppi/files/notification.rb

@@ -0,0 +1,16 @@
+module Puppi
+  module Files
+    class Notification
+      attr_reader :variables
+    
+      def initialize args = {}
+        @variables = args
+        @var = Hash.new
+        @variables.each_key do |key|
+          @var[key.to_sym] = @variables[key]
+        end
+        @variables = @var
+      end
+    end
+  end
+end

data/lib/puppi/generate_sample_data.rb

@@ -0,0 +1,45 @@
+module Puppi
+  class GenerateSampleData
+    def initialize
+    end
+    
+    def helpers
+      write_file '/helpers/standard.yml', '--- 
+:info: 
+  -
+    :command: echo "+ %{name} +"
+    :description: "info module name for tests"
+:check:
+  -
+    :command: echo "| %{name} |"
+    :description: "check module name for tests"
+  -
+    :command: echo "| %{version} |"
+    :description: "check module version"'
+    end
+    
+    def datafiles
+      write_file '/data/standard_openssh.yml', '--- 
+name: openssh
+version: 1.0'
+      write_file '/data/standard_hostname.yml', '--- 
+name: hostname'
+    end
+    
+    def notifications
+      write_file '/notifications/mail_user1.yml', '--- 
+from: puppi@puppi.com
+to: user1@mail.com
+subject: \'[puppi] notification\''
+      write_file '/notifications/mail_user2.yml', '--- 
+from: puppi@puppi.com
+to: user2@mail.com
+subject: \'[puppi] notification\''
+    end
+    
+    private
+    def write_file file, string
+      File.open(Puppi::puppidir+file, 'w') {|f| f.write(string) }
+    end
+  end
+end

data/lib/puppi/loader.rb

@@ -0,0 +1,46 @@
+module Puppi
+  class Loader
+    
+    attr_reader :data, :datafiles, :helpers, :notifications
+    
+    def load_all (file_type, puppi_module = nil, notification_method = nil)  
+      if file_type == 'data' and puppi_module != nil
+        file_glob = '*_'+puppi_module
+      elsif file_type == 'notifications' and notification_method != nil
+        file_glob = notification_method + '_*'
+      else
+        file_glob = '*'
+      end
+      
+      @all = Array.new
+      Dir.glob(Puppi::puppidir+'/'+file_type+'/'+file_glob+'.yml').each do |file|
+        @all << File.basename(file, '.yml')
+      end
+      @all
+    end
+    
+    def load_helperfile helper, action
+      @helpers = load_all('helpers') unless not @helpers.nil?
+      raise 'Invalid Helper' unless @helpers.include? helper
+      @helper_content = YAML.load(File.read(Puppi::puppidir+"/helpers/"+helper+".yml"))
+      @helper_commands = Array.new
+      return nil unless not @helper_content[action.to_sym].nil?
+      @helper_content[action.to_sym].each do |command|
+        @helper_commands << Puppi::Files::Helper.new(command)
+      end
+      @helper_commands
+    end
+
+    def load_datafile file
+      @datafiles = load_all('data') unless not @datafiles.nil?
+      raise 'Invalid Datafile' unless @datafiles.include? file
+      Puppi::Files::Datafile.new(YAML.load(File.read(Puppi::puppidir+"/data/"+file+".yml")))
+    end
+
+    def load_notification file
+      @notifications = load_all('notifications') unless not @notifications.nil?
+      raise 'Invalid Notification' unless @notifications.include? file
+      Puppi::Files::Notification.new(YAML.load(File.read(Puppi::puppidir+"/notifications/"+file+".yml")))
+    end
+  end
+end

data/lib/puppi/notification.rb

@@ -0,0 +1,40 @@
+module Puppi
+  class Notification
+    
+    attr_reader :notify_methods
+    
+    def initialize(notifications, output)
+      @notify_methods = Array.new
+      
+      if notifications.empty?
+        notifier = Puppi::Notifications::Stdout.new
+        notifier.output(output)
+        @notify_methods << 'stdout'
+        return
+      end
+      @loader = Puppi::Loader.new
+      validate_notifications_methods notifications
+      notifications.each do |notification|
+        notifier = Puppi::Notifications.class_eval(notification.capitalize).new
+        if notifier.respond_to? 'output'
+          notifier.output(output)
+          @notify_methods << notification
+        end
+      end
+    end
+    
+    def validate_notifications_methods (notifications)
+      notifications.each do |notification|
+        if !valid_method? notification
+          raise "unknown notification method"
+        end
+      end
+    end
+    
+    private
+    def valid_method? (method)
+      @valid_methods = Puppi::Notifications.constants.select {|c| Class === Puppi::Notifications.const_get(c)}
+      @valid_methods.include? method.capitalize.to_sym
+    end
+  end
+end

data/lib/puppi/notifications/mail.rb

@@ -0,0 +1,45 @@
+require 'mail'
+
+module Puppi
+  module Notifications
+    class Mail
+      def initialize
+        @loader = Puppi::Loader.new
+      end
+      
+      def output(output)
+        @@output = output
+        mails = load_all
+        mails.each do |mail|
+          mailer = @loader.load_notification(mail)
+          send_mail (mailer) if valid_mailer? (mailer)
+        end
+      end
+      
+      private
+      def send_mail (mail)
+        mail = ::Mail.new do
+                  from    mail.variables[:from]
+                  to      mail.variables[:to]
+                  subject mail.variables[:subject]
+                  body    @@output
+        end
+        mail.deliver!
+      end
+      
+      def valid_mailer? (mailer)
+        return false if mailer.class != Puppi::Files::Notification
+        required_fields = %w[ from to subject ]
+        required_fields.each do |required_field|
+          return false unless mailer.variables.has_key? required_field.to_sym
+        end
+        return true
+      end
+      
+      def load_all
+        @loader.load_all('notifications', nil, 'mail')
+      end
+    end
+  end
+end
+    

data/lib/puppi/notifications/stdout.rb

@@ -0,0 +1,12 @@
+module Puppi
+  module Notifications
+    class Stdout
+      def initialize
+      end
+      
+      def output(output)
+        puts output
+      end
+    end
+  end
+end

data/lib/puppi/version.rb

@@ -0,0 +1,3 @@
+module Puppi
+  VERSION = "0.0.1alpha"
+end

data/puppi.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "puppi/version"
+
+Gem::Specification.new do |s|
+  s.name        = "puppi"
+  s.version     = Puppi::VERSION
+  s.authors     = ["Celso Fernandes"]
+  s.email       = ["fernandes@zertico.com"]
+  s.homepage    = "http://fernandes.github.com/puppi"
+  s.summary     = %q{Puppet module to manage applications deployments and servers local management}
+  s.description = <<-EOF
+Puppi is a Puppet module that lets sysadmins standardize, manage and automate the deployment of web applications 
+and provides quick and standard commands to obtain informations about the system and what’s is going on it.
+
+Its structure provides FULL flexibility on the actions required for virtually any kind of application deployment 
+and information gathering.
+EOF
+
+  s.rubyforge_project = "puppi"
+
+  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"
+end

data/spec/puppi/action_spec.rb

@@ -0,0 +1,56 @@
+require "spec_helper"
+require 'puppi'
+
+# ar = {:action => 'info', :puppi_module => 'hostname', :notification => ['mail', 'mq']}
+
+describe "Puppi::Action" do
+  
+  before(:each) do
+    Puppi::initial_checks
+    Puppi::GenerateSampleData.new.helpers
+    Puppi::GenerateSampleData.new.datafiles
+  end
+        
+  it "should respond to check action" do
+    ar = {:action => 'check', :puppi_module => nil}
+    Puppi::Action.new({:action => 'check', :puppi_module => nil}).should respond_to(:execute).with(1).argument
+  end
+  
+  it "should respond to log action" do
+    Puppi::Action.new({:action => 'log', :puppi_module => nil}).should respond_to(:execute).with(1).argument
+  end
+  
+  it "should respond to info action" do
+    Puppi::Action.new({:action => 'info', :puppi_module => nil}).should respond_to(:execute).with(1).argument
+  end
+  
+  it "should not respond to an unknown action" do
+    expect { Puppi::Action.new({:action => :unknow_action, :puppi_module => nil}) }.to raise_error "No Action Found"
+  end
+  
+  it "should return module name if puppi module is specified" do
+    Puppi::Action.new({:action => 'check', :puppi_module => 'openssh'}).puppi_module.to_s.should match(/openssh/)
+  end
+  
+  it "should return nil as module name name if no puppi module is specified" do
+    Puppi::Action.new({:action => 'check', :puppi_module => nil}).puppi_module.should be_a(NilClass)
+  end
+  
+  it "should return all command output when running info command" do
+    output = Puppi::Action.new({:action => 'info', :puppi_module => nil}).output
+    output.should be_an(Array)
+    output.should have(2).items
+    output.should include("+ hostname +\n")
+    output.should include("+ openssh +\n")
+  end
+  
+  it "should return all command output when running check command" do
+    output = Puppi::Action.new({:action => 'check', :puppi_module => nil}).output
+    output.should be_an(Array)
+    output.should have(4).items
+    output.should include("| hostname |\n")
+    output.should include(nil)
+    output.should include("| openssh |\n")
+    output.should include("| 1.0 |\n")
+  end
+end

data/spec/puppi/files/helper_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+require 'puppi'
+require 'fileutils'
+
+describe "Puppi::Helper" do
+  
+  before(:each) do
+    Puppi::initial_checks
+    Puppi::GenerateSampleData.new.helpers
+    #Puppi::GenerateSampleData.new.datafiles
+  end
+
+  it "should return a array with all helpers" do
+    #Dir.glob(Puppi::puppidir+'/helpers/*.yml')
+  end
+end

data/spec/puppi/generate_sample_data_spec.rb

@@ -0,0 +1,58 @@
+require "spec_helper"
+require 'puppi'
+require 'fileutils'
+
+describe "Puppi::GenerateSampleData" do
+  
+  before(:each) do
+    Puppi::initial_checks
+    Puppi::GenerateSampleData.new.helpers
+    Puppi::GenerateSampleData.new.datafiles
+    Puppi::GenerateSampleData.new.notifications
+  end
+
+  it "should the standard helper" do
+    standard_helper = File.open(Puppi::puppidir+'/helpers/standard.yml', 'rb') { |file| file.read }
+    standard_helper.should eql '--- 
+:info: 
+  -
+    :command: echo "+ %{name} +"
+    :description: "info module name for tests"
+:check:
+  -
+    :command: echo "| %{name} |"
+    :description: "check module name for tests"
+  -
+    :command: echo "| %{version} |"
+    :description: "check module version"'
+  end
+  
+  it "should the standard datafile for openssh module" do
+    standard_helper = File.open(Puppi::puppidir+'/data/standard_openssh.yml', 'rb') { |file| file.read }
+    standard_helper.should eql '--- 
+name: openssh
+version: 1.0'
+  end
+  
+  it "should the standard datafile for hostname module" do
+    standard_helper = File.open(Puppi::puppidir+'/data/standard_hostname.yml', 'rb') { |file| file.read }
+    standard_helper.should eql '--- 
+name: hostname'
+  end
+  
+  it "should generate the standard notification to user1@mail.com for mail method" do
+    standard_helper = File.open(Puppi::puppidir+'/notifications/mail_user1.yml', 'rb') { |file| file.read }
+    standard_helper.should eql '--- 
+from: puppi@puppi.com
+to: user1@mail.com
+subject: \'[puppi] notification\''
+  end
+  
+  it "should generate the standard notification to user2@mail.com for mail method" do
+    standard_helper = File.open(Puppi::puppidir+'/notifications/mail_user2.yml', 'rb') { |file| file.read }
+    standard_helper.should eql '--- 
+from: puppi@puppi.com
+to: user2@mail.com
+subject: \'[puppi] notification\''
+  end
+end

data/spec/puppi/loader_spec.rb

@@ -0,0 +1,87 @@
+require "spec_helper"
+require 'puppi'
+
+describe "Puppi::Loader" do
+  
+  before(:each) do
+    @loader = Puppi::Loader.new
+  end
+  
+  context "loading helpers" do
+     before(:each) do
+       Puppi::initial_checks
+       Puppi::GenerateSampleData.new.helpers
+     end
+   
+     it "should load all helpers files" do
+       @helperfiles = @loader.load_all('helpers')
+       @helperfiles.should be_a(Array)
+       @helperfiles.should have(1).items
+       @helperfiles.should include('standard')
+    end
+  end
+
+  context "loading data files" do
+    before(:each) do
+     Puppi::initial_checks
+     Puppi::GenerateSampleData.new.datafiles
+    end
+
+    it "should load all data files" do
+      @datafiles = @loader.load_all('data')
+      @datafiles.should be_a(Array)
+      @datafiles.should have(2).items
+    end
+    
+    it "should load all hostname data files" do
+      @datafiles = @loader.load_all('data', 'hostname')
+      @datafiles.should be_a(Array)
+      @datafiles.should have(1).items
+    end
+  
+    it "should load all openssh standard data file" do
+      @p = @loader.load_datafile('standard_openssh')
+      @p.should be_a(Puppi::Files::Datafile)
+      @p.variables.should have(2).items
+    end
+  
+    it "should load all hostname standard data file" do
+      @p = @loader.load_datafile('standard_hostname')
+      @p.should be_a(Puppi::Files::Datafile)
+      @p.variables.should have(1).items
+    end
+  
+    it "should raise an exception for a invalid data file" do
+      expect { @loader.load_datafile('invalid_datafile') }.to raise_error("Invalid Datafile")
+    end
+  end
+
+  context "loading notification files" do
+    before(:each) do
+     Puppi::initial_checks
+     Puppi::GenerateSampleData.new.notifications
+    end
+
+    it "should load all notification files" do
+      @notifications = @loader.load_all('notifications')
+      @notifications.should be_a(Array)
+      @notifications.should have(2).items
+    end
+    
+    it "should load all notification files for mail method" do
+      @notifications = @loader.load_all('notifications', 'mail')
+      @notifications.should be_a(Array)
+      @notifications.should have(2).items
+    end
+  
+    it "should load all mail notification files" do
+      @p = @loader.load_notification('mail_user1')
+      @p.should be_a(Puppi::Files::Notification)
+      @p.variables.should have(3).items
+    end
+  
+    it "should raise an exception for a invalid notification file" do
+      expect { @loader.load_notification('notification_invalid') }.to raise_error("Invalid Notification")
+    end
+  end
+end

data/spec/puppi/notification_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+require 'puppi'
+
+describe "Puppi::Notification" do
+  
+  before(:each) do
+    @loader = Puppi::Loader.new
+  end
+
+  it "should show raise exception when a unknown method is specified" do
+    expect { Puppi::Notification.new(['unknown'], 'output') }.to raise_error(RuntimeError)
+  end
+  
+  it "should use stdout notification method when no one is specified" do
+    Puppi::Notification.new([], 'output').notify_methods.should include('stdout')
+  end
+
+  it "should use stdout notification method when specified" do
+    Puppi::Notification.new(['stdout'], 'output').notify_methods.should include('stdout')
+  end
+    
+  it "should use mail notification method when specified" do
+    Puppi::Notification.new(['mail'], 'output').notify_methods.should include('mail')
+  end
+  
+  it "should use mail and stdout notification methods when both are specified" do
+    @notifications_used = Puppi::Notification.new(['mail', 'stdout'], 'output')
+    @notifications_used.notify_methods.should include('mail')
+    @notifications_used.notify_methods.should include('stdout')
+  end
+end

data/spec/puppi/notifications/mail_spec.rb

@@ -0,0 +1,58 @@
+require "spec_helper"
+require 'puppi'
+
+
+describe "Puppi::Notifications::Mail" do
+  include Mail::Matchers
+    
+  before(:all) do
+    Puppi::initial_checks
+    @generator = Puppi::GenerateSampleData.new
+    @generator.helpers
+    @generator.datafiles
+    @generator.notifications
+    Mail::TestMailer.deliveries.clear
+    mailer = Puppi::Notifications::Mail.new
+    mailer.output('puppi notification body')
+  end
+  
+  it { should have_sent_email }
+  it { should have_sent_email.from('puppi@puppi.com') }
+  it { should have_sent_email.to('user1@mail.com').with_subject('[puppi] notification').with_body('puppi notification body') }
+  it { should have_sent_email.to('user2@mail.com').with_subject('[puppi] notification').with_body('puppi notification body') }
+
+  it "should return invalid mailer when its not a Puppi::Files::Notification class" do
+    Puppi::Notifications::Mail.publicize_methods do
+      Puppi::Notifications::Mail.new.valid_mailer?(false).should be_false
+    end
+  end
+  
+  context "working with invalid mailer" do
+    before(:each) do
+      @hash = {"from"=>"puppi@puppi.com", "to"=>"user1@mail.com", "subject"=>"[puppi] notification"}
+    end
+    it "should return invalid when field 'to' is missing" do
+      Puppi::Notifications::Mail.publicize_methods do
+        @hash.delete('to')
+        notification = Puppi::Files::Notification.new(@hash)
+        Puppi::Notifications::Mail.new.valid_mailer?(notification).should be_false
+      end
+    end
+    
+    it "should return invalid when field 'from' is missing" do
+      Puppi::Notifications::Mail.publicize_methods do
+        @hash.delete('from')
+        notification = Puppi::Files::Notification.new(@hash)
+        Puppi::Notifications::Mail.new.valid_mailer?(notification).should be_false
+      end
+    end
+    
+    it "should return invalid when field 'subject' is missing" do
+      Puppi::Notifications::Mail.publicize_methods do
+        @hash.delete('subject')
+        notification = Puppi::Files::Notification.new(@hash)
+        Puppi::Notifications::Mail.new.valid_mailer?(notification).should be_false
+      end
+    end
+  end
+end

data/spec/puppi_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+require 'puppi'
+
+describe "Puppi" do
+  context "initial checks" do
+    it "should provide puppidir path" do
+      puppidir = Puppi::puppidir.should match(/(\/.+)+/)
+    end
+  
+    it "should create puppi data directory if it does not exists" do
+      File.exists?(Puppi::puppidir+'/data').should be_false
+      Puppi::initial_checks
+      File.exists?(Puppi::puppidir+'/data').should be_true
+    end
+  
+    it "should create puppi helpers directory if it does not exists" do
+      File.exists?(Puppi::puppidir+'/helpers').should be_false
+      Puppi::initial_checks
+      File.exists?(Puppi::puppidir+'/helpers').should be_true
+    end
+    
+    it "should create puppi notifications directory if it does not exists" do
+      File.exists?(Puppi::puppidir+'/notifications').should be_false
+      Puppi::initial_checks
+      File.exists?(Puppi::puppidir+'/notifications').should be_true
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,60 @@
+require 'fakefs/spec_helpers'
+require 'mail'
+require 'simplecov'
+
+SimpleCov.start do
+  add_filter('/vendor\/ruby/')
+end
+
+# Load support files
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+Mail.defaults do
+  delivery_method :test # in practice you'd do this in spec_helper.rb
+end
+
+RSpec.configure do |config|
+     # Ativa output colorido
+     config.color_enabled = true
+     # Define qual o framework de mocks.
+     # Pode ser :rspec, :mocha, :rr, :flexmock, :none
+     config.mock_framework = :rspec
+     # Ativa o modo de debug.
+     # É necessário ter o ruby-debug instalado.
+     #config.debug = true
+     # Exibe backtrace completo caso algum exemplo falhe.
+     config.full_backtrace = true
+     # Define uma expressão regular que irá evitar que uma
+     # linha do backtrace apareça quando um exemplo falha.
+     config.backtrace_clean_patterns << /vendor\//
+     # Inclui um módulo. Os métodos desse módulo estarão disponíveis no
+     # contexto dos métodos `it`, `specify`, `before`, `after` e `around`.
+     config.include Module.new
+     # Inclui um módulo somente nos grupos que casarem o padrão
+     # especificado pela opção `:file_path`. Esses arquivos irão
+     # ser definidos como sendo do tipo `:foo`, e irão carregar
+     # somente módulos deste tipo.
+     config.include Module.new, :type => :foo, :example_group => {:file_path => /spec\/robots/}
+     config.include FakeFS::SpecHelpers
+     # Estende o grupo de exemplos com o módulo especificado.
+     # Os métodos deste módulo estão disponíveis no contexto
+     # dos métodos `describe` e `context`.
+     config.extend Module.new
+     # Executa o bloco antes de cada exemplo de um grupo.
+     config.before {}
+     # Executa o bloco antes de todos os exemplos de um grupo.
+     config.before(:all) {}
+     # Executa o bloco depois de cada exemplo de um grupo.
+     #config.after {}
+     # Executa o bloco depois de todos os exemplos de um grupo.
+     config.after(:all) {}
+     # Executa o bloco antes e depois de cada exemplo de um grupo.
+     #config.around {}
+     # Para a execução da suíte no primeiro exemplo que falhar.
+     config.fail_fast = true
+     # Executa somente os exemplos que possuirem o filtro `:slow`.
+     # config.filter_run :slow => true
+     # Não executa os exemplos caso o bloco retorne um valor que seja
+     # avaliado como `true`.
+     #config.exclusion_filter = {:ruby => lambda {|version| RUBY_VERSION.to_s !~ /^#{version.to_s}/ }}
+end

data/spec/support/publicize_methods.rb

@@ -0,0 +1,8 @@
+class Class
+  def publicize_methods
+    saved_private_instance_methods = self.private_instance_methods
+    self.class_eval { public *saved_private_instance_methods }
+    yield
+    self.class_eval { private *saved_private_instance_methods }
+  end
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: puppi
+version: !ruby/object:Gem::Version
+  version: 0.0.1alpha
+  prerelease: 5
+platform: ruby
+authors:
+- Celso Fernandes
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-06 00:00:00.000000000 Z
+dependencies: []
+description: ! "Puppi is a Puppet module that lets sysadmins standardize, manage and
+  automate the deployment of web applications \nand provides quick and standard commands
+  to obtain informations about the system and what’s is going on it.\n\nIts structure
+  provides FULL flexibility on the actions required for virtually any kind of application
+  deployment \nand information gathering.\n"
+email:
+- fernandes@zertico.com
+executables:
+- puppi
+extensions: []
+extra_rdoc_files: []
+files:
+- .autotest
+- .gitignore
+- .rvmrc
+- .travis.yml
+- Gemfile
+- README.rdoc
+- Rakefile
+- autotest/discover.rb
+- bin/puppi
+- etc/data/standard_openssh.yaml
+- etc/helpers/standard.yaml
+- etc/t.rb
+- lib/puppi.rb
+- lib/puppi/action.rb
+- lib/puppi/files/datafile.rb
+- lib/puppi/files/helper.rb
+- lib/puppi/files/notification.rb
+- lib/puppi/generate_sample_data.rb
+- lib/puppi/loader.rb
+- lib/puppi/notification.rb
+- lib/puppi/notifications/mail.rb
+- lib/puppi/notifications/stdout.rb
+- lib/puppi/version.rb
+- puppi.gemspec
+- spec/core/rake_task.rb
+- spec/puppi/action_spec.rb
+- spec/puppi/files/datafile_spec.rb
+- spec/puppi/files/helper_spec.rb
+- spec/puppi/files/notification_spec.rb
+- spec/puppi/generate_sample_data_spec.rb
+- spec/puppi/loader_spec.rb
+- spec/puppi/notification_spec.rb
+- spec/puppi/notifications/mail_spec.rb
+- spec/puppi_spec.rb
+- spec/spec_helper.rb
+- spec/support/publicize_methods.rb
+homepage: http://fernandes.github.com/puppi
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -3422487645257531727
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: puppi
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Puppet module to manage applications deployments and servers local management
+test_files:
+- spec/core/rake_task.rb
+- spec/puppi/action_spec.rb
+- spec/puppi/files/datafile_spec.rb
+- spec/puppi/files/helper_spec.rb
+- spec/puppi/files/notification_spec.rb
+- spec/puppi/generate_sample_data_spec.rb
+- spec/puppi/loader_spec.rb
+- spec/puppi/notification_spec.rb
+- spec/puppi/notifications/mail_spec.rb
+- spec/puppi_spec.rb
+- spec/spec_helper.rb
+- spec/support/publicize_methods.rb