rmm-chef 0.10.0.rc.0

data/lib/chef/util/windows/volume.rb

@@ -0,0 +1,59 @@
+#
+# Author:: Doug MacEachern (<dougm@vmware.com>)
+# Copyright:: Copyright (c) 2010 VMware, 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.
+#
+
+#simple wrapper around Volume APIs. might be possible with WMI, but possibly more complex.
+
+require 'chef/util/windows'
+require 'windows/volume'
+
+class Chef::Util::Windows::Volume < Chef::Util::Windows
+
+  private
+  include Windows::Volume
+  #XXX not defined in the current windows-pr release
+  DeleteVolumeMountPoint =
+    Windows::API.new('DeleteVolumeMountPoint', 'S', 'B') unless defined? DeleteVolumeMountPoint
+
+  public
+
+  def initialize(name)
+    name += "\\" unless name =~ /\\$/ #trailing slash required
+    @name = name
+  end
+  
+  def device
+    buffer = 0.chr * 256
+    if GetVolumeNameForVolumeMountPoint(@name, buffer, buffer.size)
+      return buffer[0,buffer.size].unpack("Z*")[0]
+    else
+      raise ArgumentError, get_last_error
+    end
+  end
+
+  def delete
+    unless DeleteVolumeMountPoint.call(@name)
+      raise ArgumentError, get_last_error
+    end
+  end
+
+  def add(device)
+    unless SetVolumeMountPoint(@name, device)
+      raise ArgumentError, get_last_error
+    end
+  end
+end

data/lib/chef/version.rb

@@ -0,0 +1,23 @@
+#
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2010-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.
+
+class Chef
+  CHEF_ROOT = File.dirname(File.expand_path(File.dirname(__FILE__)))
+  VERSION = '0.10.0.rc.0'
+end
+
+# NOTE: the Chef::Version class is defined in version_class.rb

data/lib/chef/version_class.rb

@@ -0,0 +1,70 @@
+# Author:: Seth Falcon (<seth@opscode.com>)
+# Author:: Christopher Walters (<cw@opscode.com>)
+# Copyright:: Copyright 2010-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.
+
+class Chef
+  class Version
+    include Comparable
+    attr_reader :major, :minor, :patch
+
+    def initialize(str="")
+      @major, @minor, @patch = parse(str)
+    end
+
+    def inspect
+      "#{@major}.#{@minor}.#{@patch}"
+    end
+
+    def to_s
+      "#{@major}.#{@minor}.#{@patch}"
+    end
+
+    def <=>(v)
+      [:major, :minor, :patch].each do |method|
+        ans = (self.send(method) <=> v.send(method))
+        return ans if ans != 0
+      end
+      0
+    end
+
+    def hash
+      # Didn't put any thought or research into this, probably can be
+      # done better
+      to_s.hash
+    end
+
+    # For hash
+    def eql?(other)
+      other.is_a?(Version) && self == other
+    end
+
+    private
+
+    def parse(str="")
+      @major, @minor, @patch =
+        case str.to_s
+        when /^(\d+)\.(\d+)\.(\d+)$/
+          [ $1.to_i, $2.to_i, $3.to_i ]
+        when /^(\d+)\.(\d+)$/
+          [ $1.to_i, $2.to_i, 0 ]
+        else
+          msg = "'#{str.to_s}' does not match 'x.y.z' or 'x.y'"
+          raise Chef::Exceptions::InvalidCookbookVersion.new( msg )
+        end
+    end
+
+  end
+end

data/lib/chef/version_constraint.rb

@@ -0,0 +1,116 @@
+# Author:: Seth Falcon (<seth@opscode.com>)
+# Author:: Christopher Walters (<cw@opscode.com>)
+# Copyright:: Copyright 2010-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/version_class'
+
+class Chef
+  class VersionConstraint
+    DEFAULT_CONSTRAINT = ">= 0.0.0"
+    STANDARD_OPS = %w(< > <= >=)
+    OPS = %w(< > = <= >= ~>)
+    PATTERN = /^(#{OPS.join('|')}) (.+)$/
+
+    attr_reader :op, :version
+
+    def initialize(constraint_spec=DEFAULT_CONSTRAINT)
+      case constraint_spec
+      when nil
+        parse(DEFAULT_CONSTRAINT)
+      when Array
+        parse_from_array(constraint_spec)
+      when String
+        parse(constraint_spec)
+      else
+        msg = "VersionConstraint should be created from a String. You gave: #{constraint_spec.inspect}"
+        raise Chef::Exceptions::InvalidVersionConstraint, msg
+      end
+    end
+
+    def include?(v)
+      version = if v.respond_to? :version # a CookbookVersion-like object
+                  Chef::Version.new(v.version.to_s)
+                else
+                  Chef::Version.new(v.to_s)
+                end
+     do_op(version)
+    end
+
+    def inspect
+      "(#{@op} #{@version})"
+    end
+
+    def to_s
+      "#{@op} #{@version}"
+    end
+
+    def eql?(o)
+      o.class == self.class && @op == o.op && @version == o.version
+    end
+    alias_method :==, :eql?
+
+    private
+
+    def do_op(other_version)
+      if STANDARD_OPS.include? @op
+        other_version.send(@op.to_sym, @version)
+      elsif @op == '='
+        other_version == @version
+      elsif @op == '~>'
+        if @missing_patch_level
+          (other_version.major == @version.major &&
+           other_version.minor >= @version.minor)
+        else
+          (other_version.major == @version.major &&
+           other_version.minor == @version.minor &&
+           other_version.patch >= @version.patch)
+        end
+      else                      # should never happen
+        raise "bad op #{@op}"
+      end
+    end
+
+    def parse_from_array(constraint_spec)
+      if constraint_spec.empty?
+        parse(DEFAULT_CONSTRAINT)
+      elsif constraint_spec.size == 1
+        parse(constraint_spec.first)
+      else
+        msg = "only one version constraint operation is supported, but you gave #{constraint_spec.size} "
+        msg << "['#{constraint_spec.join(', ')}']"
+        raise Chef::Exceptions::InvalidVersionConstraint, msg
+      end
+    end
+
+    def parse(str)
+      @missing_patch_level = false
+      if str.index(" ").nil? && str =~ /^[0-9]/
+        # try for lone version, implied '='
+        @version = Chef::Version.new(str)
+        @op = "="
+      elsif PATTERN.match str
+        @op = $1
+        raw_version = $2
+        @version = Chef::Version.new(raw_version)
+        if raw_version.split('.').size == 2
+          @missing_patch_level = true
+        end
+      else
+        raise Chef::Exceptions::InvalidVersionConstraint, "'#{str}'"
+      end
+    end
+
+  end
+end

data/lib/chef/webui_user.rb

@@ -0,0 +1,231 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Nuo Yan (<nuo@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 WebUIUser
+    
+    attr_accessor :name, :validated, :admin, :openid, :couchdb
+    attr_reader   :password, :salt, :couchdb_id, :couchdb_rev
+    
+    include Chef::Mixin::ParamsValidate
+    
+    DESIGN_DOCUMENT = {
+      "version" => 3,
+      "language" => "javascript",
+      "views" => {
+        "all" => {
+          "map" => <<-EOJS
+            function(doc) {
+              if (doc.chef_type == "webui_user") {
+                emit(doc.name, doc);
+              }
+            }
+          EOJS
+        },
+        "all_id" => {
+          "map" => <<-EOJS
+          function(doc) {
+            if (doc.chef_type == "webui_user") {
+              emit(doc.name, doc.name);
+            }
+          }
+          EOJS
+        },
+      },
+    }
+    
+    # Create a new Chef::WebUIUser object.
+    def initialize(opts={})
+      @name, @salt, @password = opts['name'], opts['salt'], opts['password']
+      @openid, @couchdb_rev, @couchdb_id = opts['openid'], opts['_rev'], opts['_id']
+      @admin = false
+      @couchdb = Chef::CouchDB.new
+    end
+    
+    def name=(n)
+      @name = n.gsub(/\./, '_')
+    end
+    
+    def admin?
+      admin
+    end
+    
+    # Set the password for this object.
+    def set_password(password, confirm_password=password) 
+      raise ArgumentError, "Passwords do not match" unless password == confirm_password
+      raise ArgumentError, "Password cannot be blank" if (password.nil? || password.length==0)
+      raise ArgumentError, "Password must be a minimum of 6 characters" if password.length < 6
+      generate_salt
+      @password = encrypt_password(password)      
+    end
+    
+    def set_openid(given_openid)
+      @openid = given_openid
+    end 
+    
+    def verify_password(given_password)
+      encrypt_password(given_password) == @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,
+        'openid' => openid,
+        'admin' => admin,
+        'chef_type' => 'webui_user',
+      }
+      result["_id"]  = @couchdb_id if @couchdb_id  
+      result["_rev"] = @couchdb_rev if @couchdb_rev
+      result.to_json(*a)
+    end
+    
+    # Create a Chef::WebUIUser from JSON
+    def self.json_create(o)
+      me = new(o)
+      me.admin = o["admin"]
+      me
+    end
+    
+    # List all the Chef::WebUIUser 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.cdb_list(inflate=false)
+      rs = Chef::CouchDB.new.list("users", 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(:user) do |n|
+          response[n.name] = n unless n.nil?
+        end
+        response
+      else
+        r.get_rest("users")
+      end
+    end
+    
+    # Load an WebUIUser by name from CouchDB
+    def self.cdb_load(name)
+      Chef::CouchDB.new.load("webui_user", name)
+    end
+    
+    # Load a User by name
+    def self.load(name)
+      r = Chef::REST.new(Chef::Config[:chef_server_url])
+      r.get_rest("users/#{name}")
+    end
+    
+    
+    # Whether or not there is an WebUIUser with this key.
+    def self.has_key?(name)
+      Chef::CouchDB.new.has_key?("webui_user", name)
+    end
+    
+    # Remove this WebUIUser from the CouchDB
+    def cdb_destroy
+      couchdb.delete("webui_user", @name, @couchdb_rev)
+    end
+    
+    # Remove this WebUIUser via the REST API
+    def destroy
+      r = Chef::REST.new(Chef::Config[:chef_server_url])
+      r.delete_rest("users/#{@name}")
+    end
+    
+    # Save this WebUIUser to the CouchDB
+    def cdb_save
+      results = couchdb.store("webui_user", @name, self)
+      @couchdb_rev = results["rev"]
+    end
+    
+    # Save this WebUIUser via the REST API
+    def save
+      r = Chef::REST.new(Chef::Config[:chef_server_url])
+      begin
+        r.put_rest("users/#{@name}", self)
+      rescue Net::HTTPServerException => e
+        if e.response.code == "404"
+          r.post_rest("users", self)
+        else
+          raise e
+        end
+      end
+      self
+    end
+    
+    # Create the WebUIUser via the REST API
+    def create
+      r = Chef::REST.new(Chef::Config[:chef_server_url])
+      r.post_rest("users", self)
+      self
+    end
+    
+    # Set up our CouchDB design document
+    def self.create_design_document(couchdb=nil)
+      couchdb ||= Chef::CouchDB.new
+      couchdb.create_design_document("users", DESIGN_DOCUMENT)
+    end
+    
+    #return true if an admin user exists. this is pretty expensive (O(n)), should think of a better way (nuo)
+    def self.admin_exist
+      users = self.cdb_list
+      users.each do |u|
+        user = self.cdb_load(u)
+        if user.admin
+          return user.name
+        end
+      end
+      nil
+    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(password)
+        Digest::SHA1.hexdigest("--#{salt}--#{password}--")
+      end
+    
+  end
+end