chef 10.34.6 → 11.0.0.beta.0

data/lib/chef/openid_registration.rb

@@ -1,187 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@opscode.com>)
-# 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.
-#
-
-require 'chef/config'
-require 'chef/mixin/params_validate'
-require 'chef/couchdb'
-require 'chef/index_queue'
-require 'digest/sha1'
-require 'chef/json_compat'
-
-class Chef
-  class OpenIDRegistration
-    
-    attr_accessor :name, :salt, :validated, :password, :couchdb_rev, :admin
-    
-    include Chef::Mixin::ParamsValidate
-    include Chef::IndexQueue::Indexable
-    
-    DESIGN_DOCUMENT = {
-      "version" => 3,
-      "language" => "javascript",
-      "views" => {
-        "all" => {
-          "map" => <<-EOJS
-            function(doc) {
-              if (doc.chef_type == "openid_registration") {
-                emit(doc.name, doc);
-              }
-            }
-          EOJS
-        },
-        "all_id" => {
-          "map" => <<-EOJS
-          function(doc) {
-            if (doc.chef_type == "openid_registration") {
-              emit(doc.name, doc.name);
-            }
-          }
-          EOJS
-        },
-        "validated" => {
-          "map" => <<-EOJS
-          function(doc) {
-            if (doc.chef_type == "openid_registration") {
-              if (doc.validated == true) {
-                emit(doc.name, doc);
-              }
-            }
-          }
-          EOJS
-        },
-        "unvalidated" => {
-          "map" => <<-EOJS
-          function(doc) {
-            if (doc.chef_type == "openid_registration") {
-              if (doc.validated == false) {
-                emit(doc.name, doc);
-              }
-            }
-          }
-          EOJS
-        },
-      },
-    }
-    
-    # Create a new Chef::OpenIDRegistration object.
-    def initialize()
-      @name = nil
-      @salt = nil
-      @password = nil
-      @validated = false
-      @admin = false
-      @couchdb_rev = nil
-      @couchdb = Chef::CouchDB.new
-    end
-    
-    def name=(n)
-      @name = n.gsub(/\./, '_')
-    end
-    
-    # Set the password for this object.
-    def set_password(password) 
-      @salt = generate_salt
-      @password = encrypt_password(@salt, password)      
-    end
-    
-    # Serialize this object as a hash 
-    def to_json(*a)
-      attributes = Hash.new
-      recipes = Array.new
-      result = {
-        'name' => @name,
-        'json_class' => self.class.name,
-        'salt' => @salt,
-        'password' => @password,
-        'validated' => @validated,
-        'admin' => @admin,
-        'chef_type' => 'openid_registration',
-      }
-      result["_rev"] = @couchdb_rev if @couchdb_rev
-      result.to_json(*a)
-    end
-    
-    # Create a Chef::Node from JSON
-    def self.json_create(o)
-      me = new
-      me.name = o["name"]
-      me.salt = o["salt"]
-      me.password = o["password"]
-      me.validated = o["validated"]
-      me.admin = o["admin"]
-      me.couchdb_rev = o["_rev"] if o.has_key?("_rev")
-      me
-    end
-    
-    # List all the Chef::OpenIDRegistration objects in the CouchDB.  If inflate is set to true, you will get
-    # the full list of all registration objects.  Otherwise, you'll just get the IDs
-    def self.list(inflate=false)
-      rs = Chef::CouchDB.new.list("registrations", inflate)
-      if inflate
-        rs["rows"].collect { |r| r["value"] }
-      else
-        rs["rows"].collect { |r| r["key"] }
-      end
-    end
-    
-    def self.cdb_list(*args)
-      list(*args)
-    end
-    
-    # Load an OpenIDRegistration by name from CouchDB
-    def self.load(name)
-      Chef::CouchDB.new.load("openid_registration", name)
-    end
-    
-    # Whether or not there is an OpenID Registration with this key.
-    def self.has_key?(name)
-      Chef::CouchDB.new.has_key?("openid_registration", name)
-    end
-    
-    # Remove this OpenIDRegistration from the CouchDB
-    def destroy
-      @couchdb.delete("openid_registration", @name, @couchdb_rev)
-    end
-    
-    # Save this OpenIDRegistration to the CouchDB
-    def save
-      results = @couchdb.store("openid_registration", @name, self)
-      @couchdb_rev = results["rev"]
-    end
-    
-    # Set up our CouchDB design document
-    def self.create_design_document(couchdb=nil)
-      couchdb ||= Chef::CouchDB.new
-      couchdb.create_design_document("registrations", DESIGN_DOCUMENT)
-    end
-    
-    protected
-    
-      def generate_salt
-        salt = Time.now.to_s
-        chars = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a
-        1.upto(30) { |i| salt << chars[rand(chars.size-1)] }
-        salt
-      end
-    
-      def encrypt_password(salt, password)
-        Digest::SHA1.hexdigest("--#{salt}--#{password}--")
-      end
-    
-  end
-end

data/lib/chef/provider/user/solaris.rb

@@ -1,90 +0,0 @@
-#
-# Author:: Stephen Nelson-Smith (<sns@opscode.com>)
-# Author:: Jon Ramsey (<jonathon.ramsey@gmail.com>)
-# Copyright:: Copyright (c) 2012 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.
-
-class Chef
-  class Provider
-    class User
-      class Solaris < Chef::Provider::User::Useradd
-        UNIVERSAL_OPTIONS = [[:comment, "-c"], [:gid, "-g"], [:shell, "-s"], [:uid, "-u"]]
-
-        attr_writer :password_file
-
-        def initialize(new_resource, run_context)
-          @password_file = "/etc/shadow"
-          super
-        end
-
-        def create_user
-          super
-          manage_password
-        end
-
-        def manage_user
-          manage_password
-          super
-        end
-
-      private
-
-        def manage_password
-          if @current_resource.password != @new_resource.password && @new_resource.password
-            Chef::Log.debug("#{@new_resource} setting password to #{@new_resource.password}")
-            write_shadow_file
-          end
-        end
-
-        def write_shadow_file
-          buffer = Tempfile.new("shadow", "/etc")
-          ::File.open(@password_file) do |shadow_file|
-            shadow_file.each do |entry|
-              user = entry.split(":").first
-              if user == @new_resource.username
-                buffer.write(updated_password(entry))
-              else
-                buffer.write(entry)
-              end
-            end
-          end
-          buffer.close
-
-          # FIXME: mostly duplicates code with file provider deploying a file
-          mode = ::File.stat(@password_file).mode & 07777
-          uid  = ::File.stat(@password_file).uid
-          gid  = ::File.stat(@password_file).gid
-
-          FileUtils.chown uid, gid, buffer.path
-          FileUtils.chmod mode, buffer.path
-
-          FileUtils.mv buffer.path, @password_file
-        end
-
-        def updated_password(entry)
-          fields = entry.split(":")
-          fields[1] = @new_resource.password
-          fields[2] = days_since_epoch
-          fields.join(":")
-        end
-
-        def days_since_epoch
-          (Time.now.to_i / 86400).floor
-        end
-      end
-    end
-  end
-end
-

data/lib/chef/solr_query.rb

@@ -1,187 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Author:: Daniel DeLeo (<dan@opscode.com>)
-# Author:: Seth Falcon (<seth@opscode.com>)
-# Copyright:: Copyright (c) 2009-2011 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/mixin/xml_escape'
-require 'chef/log'
-require 'chef/config'
-require 'chef/couchdb'
-require 'chef/solr_query/solr_http_request'
-require 'chef/solr_query/query_transform'
-
-class Chef
-  class SolrQuery
-
-    ID_KEY = "X_CHEF_id_CHEF_X"
-    DEFAULT_PARAMS = Mash.new(:start => 0, :rows => 1000, :sort => "#{ID_KEY} asc", :wt => 'json', :indent => 'off').freeze
-    FILTER_PARAM_MAP = {:database => 'X_CHEF_database_CHEF_X', :type => "X_CHEF_type_CHEF_X", :data_bag  => 'data_bag'}
-    VALID_PARAMS = [:start,:rows,:sort,:q,:type]
-    BUILTIN_SEARCH_TYPES = ["role","node","client","environment"]
-    DATA_BAG_ITEM = 'data_bag_item'
-
-    include Chef::Mixin::XMLEscape
-
-    attr_accessor :query
-    attr_accessor :params
-
-    # Create a new Query object - takes the solr_url and optional
-    # Chef::CouchDB object to inflate objects into.
-    def initialize(couchdb = nil)
-      @filter_query = {}
-      @params = {}
-
-      if couchdb.nil?
-        @database = Chef::Config[:couchdb_database]
-        @couchdb = Chef::CouchDB.new(nil, Chef::Config[:couchdb_database])
-      else
-        unless couchdb.respond_to?(:couchdb_database)
-          Chef::Log.warn("Passing the database name to Chef::Solr::Query initialization is deprecated. Please pass in the Chef::CouchDB object instead.")
-          @database = couchdb
-          @couchdb = Chef::CouchDB.new(nil, couchdb)
-        else
-          @database = couchdb.couchdb_database
-          @couchdb = couchdb
-        end
-      end
-    end
-
-    def self.from_params(params, couchdb=nil)
-      query = new(couchdb)
-      query.params = VALID_PARAMS.inject({}) do |p, param_name|
-        p[param_name] = params[param_name] if params.key?(param_name)
-        p
-      end
-      query.update_filter_query_from_params
-      query.update_query_from_params
-      query
-    end
-
-    def filter_by(filter_query_params)
-      filter_query_params.each do |key, value|
-        @filter_query[FILTER_PARAM_MAP[key]] = value
-      end
-    end
-
-    def filter_query
-      @filter_query.map { |param, value| "+#{param}:#{value}" }.join(' ')
-    end
-
-    def filter_by_type(type)
-      case type
-      when *BUILTIN_SEARCH_TYPES
-        filter_by(:type => type)
-      else
-        filter_by(:type => DATA_BAG_ITEM, :data_bag => type)
-      end
-    end
-
-    def update_filter_query_from_params
-      filter_by(:database => @database)
-      filter_by_type(params.delete(:type))
-    end
-
-    def update_query_from_params
-      original_query = URI.decode(params.delete(:q) || "*:*")
-      @query = Chef::SolrQuery::QueryTransform.transform(original_query)
-    end
-
-    def objects
-      if !object_ids.empty?
-        @bulk_objects ||= @couchdb.bulk_get(object_ids)
-        Chef::Log.debug { "Bulk get of objects: #{@bulk_objects.inspect}" }
-        @bulk_objects
-      else
-        []
-      end
-    end
-
-    def object_ids
-      @object_ids ||= results["response"]["docs"].map { |d| d[ID_KEY] }
-    end
-
-    def results
-      @results ||= SolrHTTPRequest.select(self.to_hash)
-    end
-
-    # Search Solr for objects of a given type, for a given query.
-    def search
-      { "rows" => objects, "start" => results["response"]["start"],
-        "total" => results["response"]["numFound"] }
-    end
-
-    def to_hash
-      options = DEFAULT_PARAMS.merge(params)
-      options[:fq] = filter_query
-      options[:q] = @query
-      options
-    end
-
-    START_XML = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n".freeze
-    START_DELETE_BY_QUERY = "<delete><query>".freeze
-    END_DELETE_BY_QUERY = "</query></delete>\n".freeze
-    COMMIT = "<commit/>\n".freeze
-
-    def commit(opts={})
-      SolrHTTPRequest.update("#{START_XML}#{COMMIT}")
-    end
-
-    def delete_database(db)
-      query_data = xml_escape("X_CHEF_database_CHEF_X:#{db}")
-      xml = "#{START_XML}#{START_DELETE_BY_QUERY}#{query_data}#{END_DELETE_BY_QUERY}"
-      SolrHTTPRequest.update(xml)
-      commit
-    end
-
-    def rebuild_index(db=Chef::Config[:couchdb_database])
-      delete_database(db)
-
-      results = {}
-      [Chef::ApiClient, Chef::Node, Chef::Role, Chef::Environment].each do |klass|
-        results[klass.name] = reindex_all(klass) ? "success" : "failed"
-      end
-      databags = Chef::DataBag.cdb_list(true)
-      Chef::Log.info("Reloading #{databags.size.to_s} #{Chef::DataBag} objects into the indexer")
-      databags.each { |i| i.add_to_index; i.list(true).each { |x| x.add_to_index } }
-      results[Chef::DataBag.name] = "success"
-      results
-    end
-
-    def reindex_all(klass, metadata={})
-      begin
-        items = klass.cdb_list(true)
-        Chef::Log.info("Reloading #{items.size.to_s} #{klass.name} objects into the indexer")
-        items.each { |i| i.add_to_index }
-      rescue Net::HTTPServerException => e
-        # 404s are okay, there might not be any of that kind of object...
-        if e.message =~ /Not Found/
-          Chef::Log.warn("Could not load #{klass.name} objects from couch for re-indexing (this is ok if you don't have any of these)")
-          return false
-        else
-          raise e
-        end
-      rescue Exception => e
-        Chef::Log.fatal("Chef encountered an error while attempting to load #{klass.name} objects back into the index")
-        raise e
-      end
-      true
-    end
-
-
-  end
-end