runa-chef 0.8.0.1

data/lib/chef/daemon.rb

@@ -0,0 +1,170 @@
+#
+# Author:: AJ Christensen (<aj@junglist.gen.nz>)
+# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# I love you Merb (lib/merb-core/server.rb)
+
+require 'chef/config'
+require 'etc'
+
+class Chef
+  class Daemon
+    class << self
+      attr_accessor :name
+
+      # Daemonize the current process, managing pidfiles and process uid/gid
+      #
+      # === Parameters
+      # name<String>:: The name to be used for the pid file
+      #
+      def daemonize(name)
+        @name = name
+        pid = pid_from_file
+        unless running?
+          remove_pid_file()
+          Chef::Log.info("Daemonizing..")
+          begin
+            exit if fork
+            Process.setsid
+            exit if fork
+            Chef::Log.info("Forked, in #{Process.pid}. Priveleges: #{Process.euid} #{Process.egid}")
+            File.umask Chef::Config[:umask]
+            $stdin.reopen("/dev/null")
+            $stdout.reopen("/dev/null", "a")
+            $stdout.reopen($stdout)
+            save_pid_file
+            at_exit { remove_pid_file }
+          rescue NotImplementedError => e
+            Chef::Application.fatal!("There is no fork: #{e.message}")
+          end
+        else
+          Chef::Application.fatal!("Chef is already running pid #{pid}")
+        end
+      end
+  
+      # Check if Chef is running based on the pid_file
+      # ==== Returns
+      # Boolean::
+      # True if Chef is running
+      # False if Chef is not running
+      #
+      def running?
+        if pid_from_file.nil?
+          false
+        else
+          Process.kill(0, pid_from_file)
+          true
+        end
+      rescue Errno::ESRCH, Errno::ENOENT
+        false
+      rescue Errno::EACCES => e
+        Chef::Application.fatal!("You don't have access to the PID file at #{pid_file}: #{e.message}")
+      end
+      
+      # Gets the pid file for @name
+      # ==== Returns
+      # String::
+      #   Location of the pid file for @name
+      def pid_file
+         Chef::Config[:pid_file] or "/tmp/#{@name}.pid"
+      end
+      
+      # Suck the pid out of pid_file
+      # ==== Returns
+      # Integer::
+      #   The PID from pid_file
+      # nil::
+      #   Returned if the pid_file does not exist.
+      #
+      def pid_from_file
+        File.read(pid_file).chomp.to_i
+      rescue Errno::ENOENT, Errno::EACCES
+        nil
+      end
+    
+      # Store the PID on the filesystem
+      # This uses the Chef::Config[:pid_file] option, or "/tmp/name.pid" otherwise
+      #
+      def save_pid_file
+        file = pid_file
+        begin
+          FileUtils.mkdir_p(File.dirname(file))
+        rescue Errno::EACCES => e
+          Chef::Application.fatal!("Failed store pid in #{File.dirname(file)}, permission denied: #{e.message}")
+        end
+      
+        begin
+          File.open(file, "w") { |f| f.write(Process.pid.to_s) }
+        rescue Errno::EACCES => e
+          Chef::Application.fatal!("Couldn't write to pidfile #{file}, permission denied: #{e.message}")
+        end
+      end
+    
+      # Delete the PID from the filesystem
+      def remove_pid_file
+        FileUtils.rm(pid_file) if File.exists?(pid_file)
+      end
+           
+      # Change process user/group to those specified in Chef::Config
+      #
+      def change_privilege
+        if Chef::Config[:user] and Chef::Config[:group]
+          Chef::Log.info("About to change privilege to #{Chef::Config[:user]}:#{Chef::Config[:group]}")
+          _change_privilege(Chef::Config[:user], Chef::Config[:group])
+        elsif Chef::Config[:user]
+          Chef::Log.info("About to change privilege to #{Chef::Config[:user]}")
+          _change_privilege(Chef::Config[:user])
+        end
+      end
+    
+      # Change privileges of the process to be the specified user and group
+      #
+      # ==== Parameters
+      # user<String>:: The user to change the process to.
+      # group<String>:: The group to change the process to.
+      #
+      # ==== Alternatives
+      # If group is left out, the user will be used (changing to user:user)
+      #
+      def _change_privilege(user, group=user)
+        uid, gid = Process.euid, Process.egid
+
+        begin
+          target_uid = Etc.getpwnam(user).uid
+        rescue ArgumentError => e
+          Chef::Application.fatal!("Failed to get UID for user #{user}, does it exist? #{e.message}")
+          return false
+        end
+   
+        begin
+          target_gid = Etc.getgrnam(group).gid
+        rescue ArgumentError => e
+          Chef::Application.fatal!("Failed to get GID for group #{group}, does it exist? #{e.message}")
+          return false
+        end
+      
+        if (uid != target_uid) or (gid != target_gid)
+          Process.initgroups(user, target_gid)
+          Process::GID.change_privilege(target_gid)
+          Process::UID.change_privilege(target_uid)
+        end
+        true
+      rescue Errno::EPERM => e
+        Chef::Application.fatal!("Permission denied when trying to change #{uid}:#{gid} to #{target_uid}:#{target_gid}. #{e.message}")
+      end
+    end
+  end
+end

data/lib/chef/data_bag.rb

@@ -0,0 +1,216 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Nuo Yan (<nuo@opscode.com>)
+# Copyright:: Copyright (c) 2009 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'chef/config'
+require 'chef/mixin/params_validate'
+require 'chef/mixin/from_file'
+require 'chef/couchdb'
+require 'chef/data_bag_item'
+require 'extlib'
+require 'json'
+
+class Chef
+  class DataBag 
+    
+    include Chef::Mixin::FromFile
+    include Chef::Mixin::ParamsValidate
+    
+    DESIGN_DOCUMENT = {
+      "version" => 2,
+      "language" => "javascript",
+      "views" => {
+        "all" => {
+          "map" => <<-EOJS
+          function(doc) { 
+            if (doc.chef_type == "data_bag") {
+              emit(doc.name, doc);
+            }
+          }
+          EOJS
+        },
+        "all_id" => {
+          "map" => <<-EOJS
+          function(doc) { 
+            if (doc.chef_type == "data_bag") {
+              emit(doc.name, doc.name);
+            }
+          }
+          EOJS
+        },
+        "entries" => {
+          "map" => <<-EOJS
+          function(doc) {
+            if (doc.chef_type == "data_bag_item") {
+              emit(doc.data_bag, doc.raw_data.id);
+            }
+          }
+          EOJS
+        }
+      }
+    }
+
+    attr_accessor :couchdb_rev, :couchdb_id
+    
+    # Create a new Chef::DataBag
+    def initialize
+      @name = '' 
+      @couchdb_rev = nil
+      @couchdb_id = nil
+      @couchdb = Chef::CouchDB.new 
+    end
+
+    def name(arg=nil) 
+      set_or_return(
+        :name,
+        arg,
+        :regex => /^[\-[:alnum:]_]+$/
+      )
+    end
+
+    def to_hash
+      result = {
+        "name" => @name,
+        'json_class' => self.class.name,
+        "chef_type" => "data_bag",
+      }
+      result["_rev"] = @couchdb_rev if @couchdb_rev
+      result
+    end
+
+    # Serialize this object as a hash 
+    def to_json(*a)
+      to_hash.to_json(*a)
+    end
+    
+    # Create a Chef::Role from JSON
+    def self.json_create(o)
+      bag = new
+      bag.name(o["name"])
+      bag.couchdb_rev = o["_rev"] if o.has_key?("_rev")
+      bag.couchdb_id = o["_id"] if o.has_key?("_id")
+      bag
+    end
+    
+    # List all the Chef::DataBag objects in the CouchDB.  If inflate is set to true, you will get
+    # the full list of all Roles, fully inflated.
+    def self.cdb_list(inflate=false)
+      couchdb = Chef::CouchDB.new
+      rs = couchdb.list("data_bags", inflate)
+      if inflate
+        rs["rows"].collect { |r| r["value"] }
+      else
+        rs["rows"].collect { |r| r["key"] }
+      end
+    end
+    
+    def self.list(inflate=false)
+      r = Chef::REST.new(Chef::Config[:chef_server_url])
+      if inflate
+        response = Hash.new
+        Chef::Search::Query.new.search(:data) do |n|
+          response[n.name] = n
+        end
+        response
+      else
+        r.get_rest("data")
+      end
+    end
+    
+    # Load a Data Bag by name from CouchDB
+    def self.cdb_load(name)
+      couchdb = Chef::CouchDB.new
+      couchdb.load("data_bag", name)
+    end
+    
+    # Load a Data Bag by name via the RESTful API
+    def self.load(name)
+      r = Chef::REST.new(Chef::Config[:chef_server_url])
+      r.get_rest("data/#{name}")
+    end
+    
+    # Remove this Data Bag from CouchDB
+    def cdb_destroy
+      removed = @couchdb.delete("data_bag", @name, @couchdb_rev)
+      rs = @couchdb.get_view("data_bags", "entries", :include_docs => true, :startkey => @name, :endkey => @name)
+      rs["rows"].each do |row|
+        row["doc"].cdb_destroy
+      end
+      removed
+    end
+    
+    def destroy
+      r = Chef::REST.new(Chef::Config[:chef_server_url])
+      r.delete_rest("data/#{@name}")
+    end
+    
+    # Save this Data Bag to the CouchDB
+    def cdb_save
+      results = @couchdb.store("data_bag", @name, self)
+      @couchdb_rev = results["rev"]
+    end
+    
+    # Save the Data Bag via RESTful API
+    def save
+      r = Chef::REST.new(Chef::Config[:chef_server_url])
+      begin
+        r.put_rest("data/#{@name}", self)
+      rescue Net::HTTPServerException => e
+        if e.response.code == "404"
+          r.post_rest("data", self)
+        else
+          raise e
+        end
+      end
+      self
+    end
+    
+    #create a data bag via RESTful API
+    def create
+      r = Chef::REST.new(Chef::Config[:chef_server_url])
+      r.post_rest("data", self)
+      self
+    end
+
+    # List all the items in this Bag from CouchDB
+    # The self.load method does this through the REST API
+    def list(inflate=false)
+      rs = nil 
+      if inflate
+        rs = @couchdb.get_view("data_bags", "entries", :include_docs => true, :startkey => @name, :endkey => @name)
+        rs["rows"].collect { |r| r["doc"] }
+      else
+        rs = @couchdb.get_view("data_bags", "entries", :startkey => @name, :endkey => @name)
+        rs["rows"].collect { |r| r["value"] }
+      end
+    end
+    
+    # Set up our CouchDB design document
+    def self.create_design_document
+      couchdb = Chef::CouchDB.new
+      couchdb.create_design_document("data_bags", DESIGN_DOCUMENT)
+    end
+    
+    # As a string
+    def to_s
+      "data_bag[#{@name}]"
+    end
+
+  end
+end
+

data/lib/chef/data_bag_item.rb

@@ -0,0 +1,227 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Nuo Yan (<nuo@opscode.com>)
+# Copyright:: Copyright (c) 2009 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'chef/config'
+require 'chef/mixin/params_validate'
+require 'chef/mixin/from_file'
+require 'chef/couchdb'
+require 'extlib'
+require 'json'
+
+class Chef
+  class DataBagItem
+    
+    include Chef::Mixin::FromFile
+    include Chef::Mixin::ParamsValidate
+    
+    DESIGN_DOCUMENT = {
+      "version" => 1,
+      "language" => "javascript",
+      "views" => {
+        "all" => {
+          "map" => <<-EOJS
+          function(doc) { 
+            if (doc.chef_type == "data_bag_item") {
+              emit(doc.name, doc);
+            }
+          }
+          EOJS
+        },
+        "all_id" => {
+          "map" => <<-EOJS
+          function(doc) { 
+            if (doc.chef_type == "data_bag_item") {
+              emit(doc.name, doc.name);
+            }
+          }
+          EOJS
+        }
+      }
+    }
+
+    attr_accessor :couchdb_rev, :raw_data, :couchdb_id
+    
+    # Create a new Chef::DataBagItem
+    def initialize(couchdb=nil)
+      @couchdb_rev = nil
+      @couchdb_id = nil
+      @data_bag = nil
+      @raw_data = Mash.new
+      @couchdb = Chef::CouchDB.new 
+    end
+
+    def raw_data
+      @raw_data
+    end
+
+    def raw_data=(new_data)
+      unless new_data.kind_of?(Hash) || new_data.kind_of?(Mash)
+        raise ArgumentError, "Data Bag Items must contain a Hash or Mash!"
+      end
+      unless new_data.has_key?("id")
+        raise ArgumentError, "Data Bag Items must have an id key in the hash! #{new_data.inspect}"
+      end
+      unless new_data["id"] =~ /^[\-[:alnum:]_]+$/
+        raise ArgumentError, "Data Bag Item id does not match alphanumeric/-/_!"
+      end
+      @raw_data = new_data
+    end
+
+    def data_bag(arg=nil) 
+      set_or_return(
+        :data_bag,
+        arg,
+        :regex => /^[\-[:alnum:]_]+$/
+      )
+    end
+
+    def name
+      object_name
+    end
+
+    def object_name
+      if raw_data.has_key?('id')
+        id = raw_data['id']
+      else
+        raise ArgumentError, "You must have an 'id' or :id key in the raw data"
+      end
+     
+      data_bag_name = self.data_bag
+      unless data_bag_name
+        raise ArgumentError, "You must have declared what bag this item belongs to!"
+      end
+      "data_bag_item_#{data_bag_name}_#{id}"
+    end
+
+    def self.object_name(data_bag_name, id)
+      "data_bag_item_#{data_bag_name}_#{id}"
+    end
+
+    def to_hash
+      result = self.raw_data
+      result["chef_type"] = "data_bag_item"
+      result["data_bag"] = self.data_bag
+      result["_rev"] = @couchdb_rev if @couchdb_rev
+      result
+    end
+
+    # Serialize this object as a hash 
+    def to_json(*a)
+      result = {
+        "name" => self.object_name,
+        "json_class" => self.class.name,
+        "chef_type" => "data_bag_item",
+        "data_bag" => self.data_bag,
+        "raw_data" => self.raw_data
+      }
+      result["_rev"] = @couchdb_rev if @couchdb_rev
+      result.to_json(*a)
+    end
+    
+    # Create a Chef::DataBagItem from JSON
+    def self.json_create(o)
+      bag_item = new
+      bag_item.data_bag(o["data_bag"])
+      o.delete("data_bag")
+      o.delete("chef_type")
+      o.delete("json_class")
+      o.delete("name")
+      if o.has_key?("_rev")
+        bag_item.couchdb_rev = o["_rev"] 
+        o.delete("_rev")
+      end
+      if o.has_key?("_id")
+        bag_item.couchdb_id = o["_id"] 
+        o.delete("_id")
+      end
+      bag_item.raw_data = Mash.new(o["raw_data"])
+      bag_item
+    end
+
+    # The Data Bag Item behaves like a hash - we pass all that stuff along to @raw_data.
+    def method_missing(method_symbol, *args, &block) 
+      self.raw_data.send(method_symbol, *args, &block)
+    end
+    
+    # Load a Data Bag Item by name from CouchDB
+    def self.cdb_load(data_bag, name)
+      couchdb = Chef::CouchDB.new
+      couchdb.load("data_bag_item", object_name(data_bag, name))
+    end
+    
+    # Load a Data Bag Item by name via RESTful API
+    def self.load(data_bag, name)
+      r = Chef::REST.new(Chef::Config[:chef_server_url])
+      r.get_rest("data/#{data_bag}/#{name}")
+    end
+    
+    # Remove this Data Bag Item from CouchDB
+    def cdb_destroy
+      removed = @couchdb.delete("data_bag_item", object_name, @couchdb_rev)
+      removed
+    end
+    
+    def destroy(data_bag=data_bag, databag_item=name)
+      r = Chef::REST.new(Chef::Config[:chef_server_url])
+      r.delete_rest("data/#{data_bag}/#{databag_item}")
+    end
+     
+    # Save this Data Bag Item to CouchDB
+    def cdb_save
+      results = @couchdb.store("data_bag_item", object_name, self)
+      @couchdb_rev = results["rev"]
+    end
+    
+    # Save this Data Bag Item via RESTful API
+    def save(item_id=@raw_data['id'])
+      r = Chef::REST.new(Chef::Config[:chef_server_url])
+      begin
+        r.put_rest("data/#{data_bag}/#{item_id}", @raw_data)
+      rescue Net::HTTPServerException => e
+        if e.response.code == "404"
+          r.post_rest("data/#{data_bag}", @raw_data) 
+        else
+          raise e
+        end
+      end
+      self
+    end
+    
+    # Create this Data Bag Item via RESTful API
+    def create
+      r = Chef::REST.new(Chef::Config[:chef_server_url])
+      r.post_rest("data/#{data_bag}", @raw_data) 
+      self
+    end 
+    
+    # Set up our CouchDB design document
+    def self.create_design_document
+      couchdb = Chef::CouchDB.new
+      couchdb.create_design_document("data_bag_items", DESIGN_DOCUMENT)
+    end
+    
+    # As a string
+    def to_s
+      "data_bag_item[#{@name}]"
+    end
+
+  end
+end
+
+