Class: ChefServerSlice::Application

Inherits:
Merb::Controller
  • Object
show all
Includes:
Chef::Mixin::Checksum
Defined in:
app/controllers/application.rb

Instance Method Summary collapse

Instance Method Details

#absolute_slice_url(slice_name, *args) ⇒ String

Generate the absolute url for a slice - takes the slice’s :path_prefix into account.

Examples:

absolute_slice_url(:awesome, :format => ‘html’)

absolute_slice_url(:forum, :posts, :format => ‘xml’)

Parameters:

  • slice_name (Symbol) —

    The name of the slice - in identifier_sym format (underscored).

  • *args (Array[Symbol,Hash]) —

    There are several possibilities regarding arguments:

    • when passing a Hash only, the :default route of the current slice will be used

    • when a Symbol is passed, it’s used as the route name

    • a Hash with additional params can optionally be passed

Returns:

  • (String) —

    A uri based on the requested slice.



44
45
46
47
48
49
50
 
# File 'app/controllers/application.rb', line 44

def absolute_slice_url(slice_name, *args)
  options  = extract_options_from_args!(args) || {}
  protocol = options.delete(:protocol) || request.protocol
  host     = options.delete(:host) || request.host
  
  protocol + "://" + host + slice_url(slice_name,*args)
end

#access_denied ⇒ Object 



109
110
111
112
113
114
115
116
117
 
# File 'app/controllers/application.rb', line 109

def access_denied
  case content_type
  when :html
    store_location
    redirect slice_url(:openid_consumer), :message => { :error => "You don't have access to that, please login."}
  else
    raise Unauthorized, "You must authenticate first!"
  end
end

#authorized_node ⇒ Object 



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
 
# File 'app/controllers/application.rb', line 74

def authorized_node
  if session[:level] == :admin
    Chef::Log.debug("Authorized as Administrator")
    true
  elsif session[:level] == :node
    Chef::Log.debug("Authorized as node")
    if session[:node_name] == params[:id].gsub(/\./, '_')
      true
    else
      raise(
        Unauthorized,
        "You are not the correct node for this action: #{session[:node_name]} instead of #{params[:id]}"
      )
    end
  else
    Chef::Log.debug("Unauthorized")
    raise Unauthorized, "You are not allowed to take this action."
  end
end

#escape_node_id(arg = nil) ⇒ Object 



58
59
60
61
62
63
 
# File 'app/controllers/application.rb', line 58

def escape_node_id(arg=nil)
  unless arg
    arg = params[:id] if params.has_key?(:id)
  end
  arg.gsub(/\./, '_')
end

#expand_cookbook_deps(valid_cookbooks, cl, recipe) ⇒ Object 



183
184
185
186
187
188
189
190
191
192
193
194
 
# File 'app/controllers/application.rb', line 183

def expand_cookbook_deps(valid_cookbooks, cl, recipe)
  cookbook = recipe
  if recipe =~ /^(.+)::/
    cookbook = $1
  end
  Chef::Log.debug("Node requires #{cookbook}")
  valid_cookbooks[cookbook] = true 
  cl.metadata[cookbook.to_sym].dependencies.each do |dep, versions|
    expand_cookbook_deps(valid_cookbooks, cl, dep) unless valid_cookbooks[dep]
  end
  valid_cookbooks
end

#fix_up_node_id ⇒ Object 



52
53
54
55
56
 
# File 'app/controllers/application.rb', line 52

def fix_up_node_id
  if params.has_key?(:id)
    params[:id].gsub!(/_/, '.')
  end
end

#get_available_recipes ⇒ Object 



217
218
219
220
221
222
223
224
225
226
227
228
229
230
 
# File 'app/controllers/application.rb', line 217

def get_available_recipes
  cl = Chef::CookbookLoader.new
  available_recipes = cl.sort{ |a,b| a.name.to_s <=> b.name.to_s }.inject([]) do |result, element|
    element.recipes.sort.each do |r| 
      if r =~ /^(.+)::default$/
        result << $1
      else
        result << r
      end
    end
    result
  end
  available_recipes
end

#load_all_files(segment, node_name = nil) ⇒ Object 



196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
 
# File 'app/controllers/application.rb', line 196

def load_all_files(segment, node_name=nil)
  cl = Chef::CookbookLoader.new
  files = Array.new
  valid_cookbooks = node_name ? specific_cookbooks(node_name, cl) : {} 
  cl.each do |cookbook|
    if node_name
      next unless valid_cookbooks[cookbook.name.to_s]
    end
    segment_files(segment, cookbook).each do |sf|
      mo = sf.match("cookbooks/#{cookbook.name}/#{segment}/(.+)")
      file_name = mo[1]
      files << { 
        :cookbook => cookbook.name, 
        :name => file_name,
        :checksum => checksum(sf)
      }
    end
  end
  files
end

#load_cookbook_segment(cookbook_id, segment) ⇒ Object

Load a cookbook and return a hash with a list of all the files of a given segment (attributes, recipes, definitions, libraries)

Parameters

cookbook_id<String>

The cookbook to load

segment<Symbol>

:attributes, :recipes, :definitions, :libraries

Returns

<Hash>

A hash consisting of the short name of the file in :name, and the full path

to the file in :file.

Raises:

  • (NotFound) 


129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
 
# File 'app/controllers/application.rb', line 129

def load_cookbook_segment(cookbook_id, segment)
  cl = Chef::CookbookLoader.new
  cookbook = cl[cookbook_id]
  raise NotFound unless cookbook
  
  files_list = segment_files(segment, cookbook)
  
  files = Hash.new
  files_list.each do |f|
    full = File.expand_path(f)
    name = File.basename(full)
    files[name] = {
      :name => name,
      :file => full,
    }
  end
  files
end

#login_required ⇒ Object 



65
66
67
68
69
70
71
72
 
# File 'app/controllers/application.rb', line 65

def 
  if session[:openid]
    return session[:openid]
  else  
    self.store_location
    throw(:halt, :access_denied)
  end
end

#redirect_back_or_default(default) ⇒ Object

Redirect to the URI stored by the most recent store_location call or to the passed default.



103
104
105
106
107
 
# File 'app/controllers/application.rb', line 103

def redirect_back_or_default(default)
  loc = session[:return_to] || default
  session[:return_to] = nil
  redirect loc
end

#segment_files(segment, cookbook) ⇒ Object 



148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
 
# File 'app/controllers/application.rb', line 148

def segment_files(segment, cookbook)
  files_list = nil
  case segment
  when :attributes
    files_list = cookbook.attribute_files
  when :recipes
    files_list = cookbook.recipe_files
  when :definitions
    files_list = cookbook.definition_files
  when :libraries
    files_list = cookbook.lib_files
  when :providers
    files_list = cookbook.provider_files
  when :resources
    files_list = cookbook.resource_files
  else
    raise ArgumentError, "segment must be one of :attributes, :recipes, :definitions, :libraries, :providers, or :resources"
  end
  files_list
end

#specific_cookbooks(node_name, cl) ⇒ Object 



169
170
171
172
173
174
175
176
177
178
179
180
181
 
# File 'app/controllers/application.rb', line 169

def specific_cookbooks(node_name, cl)
  valid_cookbooks = Hash.new
  begin
    node = Chef::Node.load(node_name)
    recipes, default_attrs, override_attrs = node.run_list.expand('couchdb')
  rescue Net::HTTPServerException
    recipes = []
  end
  recipes.each do |recipe|
    valid_cookbooks = expand_cookbook_deps(valid_cookbooks, cl, recipe)
  end
  valid_cookbooks
end

#store_location ⇒ Object

Store the URI of the current request in the session.

We can return to this location by calling #redirect_back_or_default.



97
98
99
 
# File 'app/controllers/application.rb', line 97

def store_location
  session[:return_to] = request.uri
end