gluez 0.2.1 → 0.3

data/lib/gluez/context.rb

@@ -0,0 +1,131 @@
+module Gluez
+  # A context in gluez is a unit of work. It contains one or multiple resources. Context-wide variables can set/get as properties.
+  # A context can include a recipe, which is an isolated context of it's own. We can set properties of a recipe from the outer context.
+  # This enables us to write modular and reusable recipes.
+  class Context
+    
+    # An array of all resources in this context
+    attr_reader :resources
+    
+    # A reference to the outer context
+    attr_reader :parent
+    
+    def initialize(parent=nil, name=nil, &block)
+      @parent = parent
+      @name = name
+      
+      @resources = []
+      @properties = {}
+      
+      $gluez = self
+      instance_eval(&block) if block
+      
+      if self.root == self
+        self.generate($simulate == true)
+      else
+        $gluez = parent
+      end
+    end
+    
+    # Returns the outer most context
+    def root
+      self.parent ? self.parent.root : self
+    end
+    
+    def default(name, name2)
+      unless @properties.key?(name)
+        if name2.is_a?(Symbol)
+          set(name, get(name2))
+        else
+          set(name, name2)
+        end
+      end
+    end
+    
+    def expect(name)
+      raise "missing #{name}" unless get(name)
+    end
+    
+    def locate(resource)
+      File.dirname($0) + (@name.nil? ? "" : "/recipes/#{@name}") + "/files/#{resource}"
+    end
+    
+    def read(resource)
+      File.read $gluez.locate(resource)
+    end
+    
+    # Set a property value
+    def set(name, value)
+      @properties[name] = value
+    end
+    
+    # Get a property value
+    def get(name)
+      @properties[name]
+    end
+    
+    # Includes a recipe. A new context will be created. The passed block will be executed in the scope of the new context.
+    def include(name, &block)
+      Gluez::Context.new(self, name) do |c|
+        c.instance_eval(&block) if block
+        load "#{File.dirname($0)}/recipes/#{name}/#{name}.rb"
+      end
+    end
+    
+    # Loops through all resources, collect their generated code, format and return it.
+    def generate(simulate)
+      code = "#!/bin/bash"
+            
+      code += "\n" + @resources.collect do |res|
+        res.generate(simulate).join("\n")
+      end.join("\n")
+
+      code += "\n" + @resources.select{|r| !r.lazy}.collect do |res|
+        res.function_name
+      end.join("\n")
+      
+      code = Gluez::format(code)
+      
+      if Gluez.options.include?("--ssh")
+        code64 = Base64.encode64(code)
+
+        cmd = %(code=\\"#{code64.strip}\\" && echo \\\$code | base64 -i -d - | /bin/bash)
+        ssh = "ssh -t whale01 \"sudo su -l root -c '#{cmd}'\""
+        
+        puts ssh
+      else
+        puts code
+      end
+      
+    end
+    
+    def self.load_resources
+      dirs = [File.dirname($0), File.dirname(__FILE__)].collect{|d| "#{d}/resources"}
+
+      dirs.each do |dir|
+        next unless File.exist?(dir)
+        Dir.glob(dir + "/*") do |file|
+          require file
+        end
+      end
+    end
+
+    def self.register(method_name, &block)
+      define_method method_name do |name, &block2|
+        res = Gluez::Resource.new(self, method_name, name)
+
+        res.class.class_eval do
+          define_method("ready!".to_sym) do
+            res.instance_eval(&block2) if block2
+            res.validate!
+          end
+        end
+        
+        res.instance_eval(&block)
+
+        self.root.resources << res
+      end
+    end
+    
+  end
+end

data/lib/gluez/resource.rb

@@ -0,0 +1,209 @@
+module Gluez
+  
+  module Resources
+  end
+  
+  # Resources are the building blocks of gluez. Each resource has a specification which list the attributes, their default values and the actual code to execute.
+  # The code to execute is listed as separate steps. A step consist of a chunk of code and a check, which ensures the chunk of code has been executed correctly.
+  # Complex checks can be broken down as multiple simple checks. These will be AND'ed later on.
+  #
+  # Resources will be executed as root per default. The special attribute user can be set, so that the resource will be executed as this user.
+  class Resource
+
+    # A Step consist of a chunk of code and a check, to ensure the code has been applied successfully.
+    class Step
+      attr_accessor :checks, :code
+      def initialize
+        @checks = []
+      end
+    end
+    
+    # The name of this resource
+    attr_reader :name
+    
+    # The type of this resource
+    attr_reader :type
+    
+    # A chunk of code which will be executed before any other code defined as steps
+    attr_accessor :setup
+    
+    attr_reader :subscriptions
+    
+    def initialize(context, type, name, &block)
+      @context = context
+      @type = type.to_sym
+      @name = name
+      @steps = []
+      
+      @notifies = []
+      @subscriptions = []
+      
+      @mandatories = []
+      @optionals = []
+      
+      self.optional :user, :default => "root"
+      self.optional :lazy, :default => false
+      
+      self.accessor :setup
+    end
+    
+    def validate!
+      @mandatories.each do |it|
+        raise "no value for mandatory attribute #{it}" if self.send(it).nil?
+      end
+    end
+    
+    def mandatory(name, opts={})
+      @mandatories << name
+      self.accessor(name)
+    end
+
+    def optional(name, opts={})
+      @optionals << name
+      self.accessor(name, opts[:default])
+    end
+
+    def accessor(name, default=nil)
+      self.class.instance_eval do
+        define_method(name) do |*args|
+          if args.length == 0
+            v = instance_variable_get("@#{name}")
+            v.nil? ? default : v
+          else
+            instance_variable_set("@#{name}", args.first)
+          end
+        end
+      end
+    end
+    
+    def notify(type, name)
+      @notifies << [type, name]
+    end
+
+    def subscribe(type, name)
+      @subscriptions << [type, name]
+    end
+    
+    def assign(name)
+      self.send(name, $gluez.get(name))
+    end
+    
+    # Creates a new step for this resource. This method is called within the specification of a resource and should not be called after this phase.
+    def steps
+      step = Gluez::Resource::Step.new
+      yield(step)
+      
+      step.checks.each do |check|
+        check.gsub!("\"", "\\\"")
+      end
+      
+      @steps << step
+    end
+    
+    # Returns this resource as a bash function. The function body contains all the steps checks/codes in the order as specified for this resource.
+    # Test if the check part of a step is up2date. If not, execute the code of the step. If it is up2date now, continue with the next step, fail with an error otherwise.
+    def generate(simulate)
+      g = []
+      
+      fun = self.function_name
+      
+      g << "function #{fun} {"
+      g << "su -l #{user} -c \"#{self.setup}\"" if self.setup
+
+      if @steps.map{|s| s.checks}.flatten.empty?
+        unless simulate
+          g << "su -l #{user} -c \"#{@steps.map{|s| s.code}.join(' && ')}\""
+
+          generate_success_or_failure(g, "echo \"[applied] - #{fun}\"") do
+            g << "echo \"[not applied] - #{fun}\""
+            g << "exit 1"
+          end
+          
+          generate_notify_and_subscribe(g)
+        end
+      else
+        generate_steps_checks(g, @steps)
+        generate_success_or_failure(g, "echo \"[up2date] - #{fun}\"") do
+          g << "echo \"[not up2date] - #{fun}\""
+
+          unless simulate
+            y = @steps.length
+            if y > 1
+              (0..@steps.length-1).to_a.each do |limit|
+                generate_steps_checks(g, @steps[0..limit])
+                x = limit + 1
+
+                generate_success_or_failure(g, "echo \"[up2date] #{x}/#{y} - #{fun}\"") do
+                  g << "echo \"[not up2date] #{x}/#{y} - #{fun}\""
+                  g << "su -l #{user} -c \"#{@steps[limit].code}\""
+
+                  generate_success_or_failure(g, "echo \"[applied] #{x}/#{y} - #{fun}\"") do
+                    g << "echo \"[not applied] #{x}/#{y} - #{fun}\""
+                    g << "exit 1"
+                  end
+                end
+              end
+            else
+              g << "su -l #{user} -c \"#{@steps.first.code}\""
+
+              generate_success_or_failure(g, "echo \"[applied] - #{fun}\"") do
+                g << "echo \"[not applied] - #{fun}\""
+                g << "exit 1"
+              end
+            end
+
+            generate_notify_and_subscribe(g)
+
+          end
+        end
+      end
+
+      
+      g << "}"
+      g
+    end
+    
+    def generate_notify_and_subscribe(g)
+      @notifies.each do |run|
+        type, name = run
+
+        resource = @context.root.resources.detect{|r| r.type == type && r.name == name}
+        raise "resource #{type} #{name} does not exist" unless resource
+
+        g << resource.function_name
+      end
+
+      @context.root.resources.select{|r| r.subscriptions.include?([@type, @name])}.each do |resource|
+        g << resource.function_name
+      end
+    end
+    
+    def generate_steps_checks(g, steps)
+      g << steps.map do |step|
+        step.checks
+      end.flatten.map do |check|
+        "su -l #{user} -c \"test #{check}\""
+      end.join(" && ")
+    end
+    
+    def generate_success_or_failure(g, success)
+      g << "if [[ $? -eq 0 ]]; then"
+      g << success
+      g << "else"
+      yield
+      g << "fi"
+    end
+    
+    # Returns a bash-compatible function name for this resource
+    def function_name
+      "#{user}_#{self.type}_#{self.name}".
+        gsub('/', '_').
+        gsub(':', '_').
+        gsub("@", "_").
+        gsub("~", "_").
+        gsub(" ", "_").
+        gsub(".", "_")     
+    end
+    
+  end
+end

data/lib/gluez/resources/bash.rb

@@ -0,0 +1,11 @@
+resource :bash do
+  mandatory :code
+  mandatory :not_if
+  
+  ready!
+
+  steps do |step|
+    step.checks << self.not_if
+    step.code = self.code
+  end
+end

data/lib/gluez/resources/bash_once.rb

@@ -0,0 +1,10 @@
+resource :bash_once do
+  mandatory :code
+  
+  ready!
+  
+  steps do |step|
+    step.checks << "-f ~/.gluez/bash_once_#{self.function_name}"
+    step.code = "#{self.code.strip} && touch ~/.gluez/bash_once_#{self.function_name}"
+  end
+end

data/lib/gluez/resources/dir.rb

@@ -0,0 +1,14 @@
+resource :dir do
+  optional :chmod, :default => 755
+  
+  ready!
+  
+  steps do |step|
+    step.checks << "-d #{self.name}"
+    step.code = "mkdir #{self.name}"
+  end
+  steps do |step|
+    step.checks << %Q("\\$(stat -L --format=%a #{self.name})" = "#{self.chmod}")
+    step.code = "chmod #{self.chmod} #{self.name}"
+  end
+end

data/lib/gluez/resources/disable.rb

@@ -0,0 +1,8 @@
+resource :disable do
+  ready!
+  
+  steps do |step|
+    step.checks << "\\$(update-rc.d -n -f #{self.name} remove | grep '/etc/rc' | wc -l) -eq 0"
+    step.code = "/usr/sbin/update-rc.d -f #{self.name} remove"
+  end
+end

data/lib/gluez/resources/enable.rb

@@ -0,0 +1,8 @@
+resource :enable do
+  ready!
+  
+  steps do |step|
+    step.checks << "\\$(update-rc.d -n -f #{self.name} remove | grep '/etc/rc' | wc -l) -gt 0"
+    step.code = "/usr/sbin/update-rc.d #{self.name} defaults"
+  end
+end

data/lib/gluez/resources/file.rb

@@ -0,0 +1,23 @@
+resource :file do
+  optional :chmod, :default => 644
+  optional :chown
+  
+  ready!
+  
+  steps do |step|
+    step.checks << "-f #{self.name}"
+    step.code = "touch #{self.name}"
+  end
+  steps do |step|
+    step.checks << %Q("\\$(stat -L --format=%a #{self.name})" = "#{self.chmod}")
+    step.code = "chmod #{self.chmod} #{self.name}"
+  end
+  
+  if self.chown
+    steps do |step|
+      step.checks << %Q("\\$(stat -L --format=%U:%G #{self.name})" = "#{self.chown}")
+      step.code = "chown #{self.chown} #{self.name}"
+    end
+  end
+  
+end

data/lib/gluez/resources/gem.rb

@@ -0,0 +1,10 @@
+resource :gem do
+  mandatory :version
+  
+  ready!
+  
+  steps do |step|
+    step.checks << "\\$(gem list | awk '{print \\$1}' | grep ^#{self.name}$ | wc -l) -eq 1"
+    step.code = "gem install #{self.name} --version #{self.version} --user-install --no-rdoc --no-ri"
+  end
+end

data/lib/gluez/resources/group.rb

@@ -0,0 +1,10 @@
+resource :group do
+  mandatory :gid
+  
+  ready!
+  
+  steps do |step|
+    step.checks << "$(cat /etc/group | grep ^#{self.name}: | wc -l) -eq 1"
+    step.code = "groupadd --gid #{self.gid} #{self.name}"
+  end
+end

data/lib/gluez/resources/link.rb

@@ -0,0 +1,12 @@
+resource :link do
+  mandatory   :target
+  
+  ready!
+  
+  steps do |step|
+    step.checks << "-L #{self.name}"
+    step.checks << "\\$(file #{self.name} | grep \"#{self.name.gsub('~', '\$HOME')}: symbolic link to \\\\\\`#{self.target.gsub('~', '\$HOME')}'\" | wc -l) -eq 1"
+    
+    step.code = "ln -f -s #{self.target} #{self.name}"
+  end
+end

data/lib/gluez/resources/mount.rb

@@ -0,0 +1,19 @@
+resource :mount do
+  mandatory   :type
+  mandatory   :options
+  mandatory   :device
+  
+  optional    :options
+  
+  ready!
+  
+  steps do |step|
+    step.checks << "\\$(mount | grep \"on #{self.name} type\" | wc -l) -eq 1"
+    
+    cmd = "mount -t #{self.type}"
+    cmd = "#{cmd} -o #{self.options}" if self.options
+    cmd = "#{cmd} #{self.device} #{self.name}"
+    
+    step.code = cmd
+  end
+end

data/lib/gluez/resources/package.rb

@@ -0,0 +1,8 @@
+resource :package do
+  ready!
+  steps do |step|
+    step.checks << "\\$(apt-cache policy #{self.name} | grep Installed | wc -l) -eq 1"
+    step.checks << "\\$(apt-cache policy #{self.name} | grep Installed | grep '(none)' | wc -l) -eq 0"
+    step.code = "apt-get install #{self.name} --yes"
+  end
+end

data/lib/gluez/resources/path.rb

@@ -0,0 +1,13 @@
+resource :path do
+  ready!
+  
+  steps do |step|
+    link = self.name.gsub('/', '_').gsub('~', "/home/#{self.user}/.gluez/path/")
+    target = self.name.gsub('~', "/home/#{self.user}")
+    
+    step.checks << "-L #{link}"
+    step.checks << "\\$(ls -al #{link} | awk '{print \\$10}' | grep #{target} | wc -l) -eq 1"
+    
+    step.code = "ln -f -s #{self.name} #{link}"
+  end
+end

data/lib/gluez/resources/restart.rb

@@ -0,0 +1,6 @@
+resource :restart do
+  ready!
+  steps do |step|
+    step.code = "service #{self.name} restart"
+  end
+end

data/lib/gluez/resources/source.rb

@@ -0,0 +1,22 @@
+resource :source do
+
+  mandatory     :not_if
+  mandatory     :filename
+  mandatory     :folder
+  mandatory     :make
+  optional      :tmp_dir, :default => "~/tmp"
+
+  ready!
+  
+  steps do |step|
+    step.checks << self.not_if
+    step.code = <<-CODE
+      [ -f #{self.tmp_dir}/#{self.filename} ] && rm #{self.tmp_dir}/#{self.filename}
+      [ -d #{self.tmp_dir}/#{self.folder} ] && rm -rf #{self.tmp_dir}/#{self.folder}
+
+      wget --no-check-certificate -O #{self.tmp_dir}/#{self.filename} #{self.name}
+      tar -C #{self.tmp_dir}/ -x#{self.filename =~ /\.tar\.bz2/ ? "j" : "z"}f #{self.tmp_dir}/#{self.filename}
+      cd #{self.tmp_dir}/#{self.folder} && #{self.make}
+    CODE
+  end
+end

data/lib/gluez/resources/start.rb

@@ -0,0 +1,10 @@
+resource :start do
+  ready!
+  
+  setup = "service --status-all 1>/tmp/gluez.tmp 2>&1"
+  steps do |step|
+    step.checks << %Q("\\$(grep #{self.name} /tmp/gluez.tmp | wc -l)" = "1")
+    step.checks << %Q("\\$(service #{self.name} status | grep -E 'is running|start/running' | wc -l)" = "1")
+    step.code = "service #{self.name} start"
+  end
+end

data/lib/gluez/resources/stop.rb

@@ -0,0 +1,10 @@
+resource :stop do
+  ready!
+  
+  setup = "service --status-all 1>/tmp/gluez.tmp 2>&1"
+  steps do |step|
+    step.checks << %Q("\\$(grep #{self.name} /tmp/gluez.tmp | wc -l)" = "1")
+    step.checks << %Q("\\$(service #{self.name} status | grep -E 'is running|start/running' | wc -l)" = "0")
+    step.code = "service #{self.name} stop"
+  end
+end

data/lib/gluez/resources/transfer.rb

@@ -0,0 +1,51 @@
+require 'erb'
+require 'base64'
+
+resource :transfer do
+
+  mandatory     :content
+  optional      :chmod, :default => 644
+  
+  instance_variable_set("@vars", {})
+  def var(name, value)
+    @vars[name] = value
+  end
+  
+  ready!
+  
+  res = self
+  vars = Object.new
+  
+  vars.class.class_eval do
+    res.instance_variable_get("@vars").each_pair do |key, val|
+      next unless val
+      define_method key do
+        val
+      end
+    end
+    define_method :get_binding do
+      binding
+    end
+  end
+  
+  data = ERB.new(self.content).result(vars.get_binding)
+  base64 = Base64.encode64(data)
+  
+  setup "cat >~/.gluez_transfer <<\\DATA
+#{base64.strip}
+DATA"
+  
+  steps do |step|
+    step.checks << "-f #{self.name}"
+    step.code = "touch #{self.name}"
+  end
+  steps do |step|
+    step.checks << %Q("\\$(stat -L --format=%a #{self.name})" = "#{self.chmod}")
+    step.code = "chmod #{self.chmod} #{self.name}"
+  end
+  steps do |step|
+    step.checks << %Q("\\$(cat ~/.gluez_transfer | base64 -i -d - | md5sum - | awk '{print \\$1}')" = "\\$(md5sum #{self.name} | awk '{print \\$1}')")
+    step.code = "chmod +w #{self.name} && cat ~/.gluez_transfer | base64 -i -d - > #{self.name} && chmod #{self.chmod} #{self.name}"
+  end
+
+end

data/lib/gluez/resources/umount.rb

@@ -0,0 +1,8 @@
+resource :umount do
+  ready!
+  
+  steps do |step|
+    step.checks << "\\$(mount | grep \"on #{self.name} type\" | wc -l) -eq 0"
+    step.code = "umount #{self.name}"
+  end
+end

data/lib/gluez/resources/user.rb

@@ -0,0 +1,11 @@
+resource :user do
+  mandatory   :uid
+  mandatory   :gid
+
+  ready!
+  
+  steps do |step|
+    step.checks << "$(cat /etc/passwd | grep ^#{self.name}: | wc -l) -eq 1"
+    step.code = "useradd --create-home --uid #{self.uid} --gid #{self.gid} --shell /bin/bash #{self.name}"
+  end
+end