[OC-3564] move core Chef to the repo root \o/ \m/

The opscode/chef repository now only contains the core Chef library code
used by chef-client, knife and chef-solo!

1 files changed, 253 insertions, 0 deletions

diff --git a/lib/chef/role.rb b/lib/chef/role.rb
new file mode 100644
index 0000000000..78bbfadb88
--- /dev/null
+++ b/lib/chef/role.rb
@@ -0,0 +1,253 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Nuo Yan (<nuo@opscode.com>)
+# Author:: Christopher Brown (<cb@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/mixin/from_file'
+require 'chef/run_list'
+require 'chef/mash'
+require 'chef/json_compat'
+require 'chef/search/query'
+
+class Chef
+  class Role
+
+    include Chef::Mixin::FromFile
+    include Chef::Mixin::ParamsValidate
+
+    # Create a new Chef::Role object.
+    def initialize
+      @name = ''
+      @description = ''
+      @default_attributes = Mash.new
+      @override_attributes = Mash.new
+      @env_run_lists = {"_default" => Chef::RunList.new}
+    end
+
+    def chef_server_rest
+      Chef::REST.new(Chef::Config[:chef_server_url])
+    end
+
+    def self.chef_server_rest
+      Chef::REST.new(Chef::Config[:chef_server_url])
+    end
+
+    def name(arg=nil)
+      set_or_return(
+        :name,
+        arg,
+        :regex => /^[\-[:alnum:]_]+$/
+      )
+    end
+
+    def description(arg=nil)
+      set_or_return(
+        :description,
+        arg,
+        :kind_of => String
+      )
+    end
+
+    def run_list(*args)
+      if (args.length > 0)
+        @env_run_lists["_default"].reset!(args)
+      end
+      @env_run_lists["_default"]
+    end
+
+    alias_method :recipes, :run_list
+
+    # For run_list expansion
+    def run_list_for(environment)
+      if env_run_lists[environment].nil?
+        env_run_lists["_default"]
+      else
+        env_run_lists[environment]
+      end
+    end
+
+    def active_run_list_for(environment)
+      @env_run_lists.has_key?(environment) ? environment : '_default'
+    end
+
+    # Per environment run lists
+    def env_run_lists(env_run_lists=nil)
+      if (!env_run_lists.nil?)
+        unless env_run_lists.key?("_default")
+          msg = "_default key is required in env_run_lists.\n"
+          msg << "(env_run_lists: #{env_run_lists.inspect})"
+          raise Chef::Exceptions::InvalidEnvironmentRunListSpecification, msg
+        end
+        @env_run_lists.clear
+        env_run_lists.each { |k,v| @env_run_lists[k] = Chef::RunList.new(*Array(v))}
+      end
+      @env_run_lists
+    end
+
+    alias :env_run_list :env_run_lists
+
+    def default_attributes(arg=nil)
+      set_or_return(
+        :default_attributes,
+        arg,
+        :kind_of => Hash
+      )
+    end
+
+    def override_attributes(arg=nil)
+      set_or_return(
+        :override_attributes,
+        arg,
+        :kind_of => Hash
+      )
+    end
+
+    def to_hash
+      env_run_lists_without_default = @env_run_lists.dup
+      env_run_lists_without_default.delete("_default")
+      result = {
+        "name" => @name,
+        "description" => @description,
+        'json_class' => self.class.name,
+        "default_attributes" => @default_attributes,
+        "override_attributes" => @override_attributes,
+        "chef_type" => "role",
+
+        #Render to_json correctly for run_list items (both run_list and evn_run_lists)
+        #so malformed json does not result
+        "run_list" => run_list.run_list.map { |item| item.to_s },
+        "env_run_lists" => env_run_lists_without_default.inject({}) do |accumulator, (k, v)|
+          accumulator[k] = v.map { |x| x.to_s }
+          accumulator
+        end
+      }
+      result
+    end
+
+    # Serialize this object as a hash
+    def to_json(*a)
+      to_hash.to_json(*a)
+    end
+
+    def update_from!(o)
+      description(o.description)
+      recipes(o.recipes) if defined?(o.recipes)
+      default_attributes(o.default_attributes)
+      override_attributes(o.override_attributes)
+      env_run_lists(o.env_run_lists) unless o.env_run_lists.nil?
+      self
+    end
+
+    # Create a Chef::Role from JSON
+    def self.json_create(o)
+      role = new
+      role.name(o["name"])
+      role.description(o["description"])
+      role.default_attributes(o["default_attributes"])
+      role.override_attributes(o["override_attributes"])
+
+      # _default run_list is in 'run_list' for newer clients, and
+      # 'recipes' for older clients.
+      env_run_list_hash = {"_default" => (o.has_key?("run_list") ? o["run_list"] : o["recipes"])}
+
+      # Clients before 0.10 do not include env_run_lists, so only
+      # merge if it's there.
+      if o["env_run_lists"]
+        env_run_list_hash.merge!(o["env_run_lists"])
+      end
+      role.env_run_lists(env_run_list_hash)
+
+      role
+    end
+
+    # Get the list of all roles from the API.
+    def self.list(inflate=false)
+      if inflate
+        response = Hash.new
+        Chef::Search::Query.new.search(:role) do |n|
+          response[n.name] = n unless n.nil?
+        end
+        response
+      else
+        chef_server_rest.get_rest("roles")
+      end
+    end
+
+    # Load a role by name from the API
+    def self.load(name)
+      chef_server_rest.get_rest("roles/#{name}")
+    end
+
+    def environment(env_name)
+      chef_server_rest.get_rest("roles/#{@name}/environments/#{env_name}")
+    end
+
+    def environments
+      chef_server_rest.get_rest("roles/#{@name}/environments")
+    end
+
+    # Remove this role via the REST API
+    def destroy
+      chef_server_rest.delete_rest("roles/#{@name}")
+    end
+
+    # Save this role via the REST API
+    def save
+      begin
+        chef_server_rest.put_rest("roles/#{@name}", self)
+      rescue Net::HTTPServerException => e
+        raise e unless e.response.code == "404"
+        chef_server_rest.post_rest("roles", self)
+      end
+      self
+    end
+
+    # Create the role via the REST API
+    def create
+      chef_server_rest.post_rest("roles", self)
+      self
+    end
+
+    # As a string
+    def to_s
+      "role[#{@name}]"
+    end
+
+    # Load a role from disk - prefers to load the JSON, but will happily load
+    # the raw rb files as well.
+    def self.from_disk(name, force=nil)
+      js_file = File.join(Chef::Config[:role_path], "#{name}.json")
+      rb_file = File.join(Chef::Config[:role_path], "#{name}.rb")
+
+      if File.exists?(js_file) || force == "json"
+        # from_json returns object.class => json_class in the JSON.
+        Chef::JSONCompat.from_json(IO.read(js_file))
+      elsif File.exists?(rb_file) || force == "ruby"
+        role = Chef::Role.new
+        role.name(name)
+        role.from_file(rb_file)
+        role
+      else
+        raise Chef::Exceptions::RoleNotFound, "Role '#{name}' could not be loaded from disk"
+      end
+    end
+
+  end
+end