Class: PoolParty::Base

Inherits:
Object show all
Includes:
Callbacks, Delayed, Dslify, Parenting, SearchablePaths
Defined in:
lib/poolparty/base.rb

Direct Known Subclasses

DslBase, Resource

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Delayed

included

Methods included from Callbacks

included

Methods included from SearchablePaths

included

Constructor Details

#initialize(opts = {}, extra_opts = {}, &block) ⇒ Base

Returns a new instance of Base.



21
22
23
24
25
26
27
 
# File 'lib/poolparty/base.rb', line 21

def initialize(opts={}, extra_opts={}, &block)
  @init_block = block
  @init_opts = compile_opts(opts, extra_opts)
  
  run_with_callbacks(init_opts, &block)
  @base_name = self.name
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(m, *a, &block) ⇒ Object

If the method is missing from ourself, check the Default class for the corresponding method. If the Default class has the method, inquire from the Default class, otherwise, call super



235
236
237
238
239
240
241
 
# File 'lib/poolparty/base.rb', line 235

def method_missing(m,*a,&block)
  if Default.respond_to?(m)
    Default.send(m,*a,&block)
  else
    super
  end
end

Instance Attribute Details

#base_name ⇒ Object (readonly)

Returns the value of attribute base_name.



12
13
14
 
# File 'lib/poolparty/base.rb', line 12

def base_name
  @base_name
end

#init_opts ⇒ Object (readonly)

Returns the value of attribute init_opts.



12
13
14
 
# File 'lib/poolparty/base.rb', line 12

def init_opts
  @init_opts
end

Class Method Details

.clouds_dot_rb_dir(n = nil) ⇒ Object 



229
 
# File 'lib/poolparty/base.rb', line 229

def self.clouds_dot_rb_dir(n=nil); Pool.clouds_dot_rb_dir(n);end

.clouds_dot_rb_file(n = nil) ⇒ Object 



227
 
# File 'lib/poolparty/base.rb', line 227

def self.clouds_dot_rb_file(n=nil);Pool.clouds_dot_rb_file(n);end

Instance Method Details

#add_ordered_resources_to_result(resources, result) ⇒ Object

Add all the resources as edges of each other



180
181
182
183
184
185
186
187
 
# File 'lib/poolparty/base.rb', line 180

def add_ordered_resources_to_result(resources, result)
  arr_of_resources = resources.zip_offset(1)
  
  arr_of_resources.each do |first, second|
    result.add_edge!(first, second) unless result.edge?(first, second) or result.edge?(second, first)
    add_ordered_resources_to_result(first.resources, result)
  end
end

#after_loaded(o = {}, &block) ⇒ Object

after_loaded This is run immediately after the block given on init is yielded



69
70
 
# File 'lib/poolparty/base.rb', line 69

def after_loaded(o={}, &block)
end

#all_resources ⇒ Object 



203
204
205
206
207
 
# File 'lib/poolparty/base.rb', line 203

def all_resources
  resources.map do |res|
    [res, res.all_resources ]
  end.flatten
end

#before_load(o = {}, &block) ⇒ Object

Base callbacks for run_with_callbacks before_load This is called before the block is yielded



63
64
 
# File 'lib/poolparty/base.rb', line 63

def before_load(o={}, &block)      
end

#clouds_dot_rb_dir(n = nil) ⇒ Object 



228
 
# File 'lib/poolparty/base.rb', line 228

def clouds_dot_rb_dir(n=nil); self.class.clouds_dot_rb_dir(n);end

#clouds_dot_rb_file(n = nil) ⇒ Object

The clouds.rb file



226
 
# File 'lib/poolparty/base.rb', line 226

def clouds_dot_rb_file(n=nil); self.class.clouds_dot_rb_file(n); end

#compile_opts(o = {}, extra = {}) ⇒ Object

Try to extract the name from the options Either the first parameter is a string or it is a hash if it is a hash, just merge the two hashes If it is a string, then merge it in as the name of the instance on the hash



77
78
79
80
81
82
83
84
85
86
 
# File 'lib/poolparty/base.rb', line 77

def compile_opts(o={}, extra={})
  case o
  when Symbol, String
    extra.merge(:name => o.to_s)
  when NilClass
    extra
  else
    extra.merge(o)
  end
end

#create_graph(resources, on, result) ⇒ Object

Create the graph of resources. Blow up if a resource isn’t found that is required. If it is found, add it as an edge to the dependency graph



141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
 
# File 'lib/poolparty/base.rb', line 141

def create_graph(resources, on, result)
  # add_ordered_resources_to_result(without_dependencies, result)
  first_layer_of_ordered_resources = resources_without_dependencies.zip_offset(1)
  first_layer_of_ordered_resources.each do |first, second|
    result.add_edge!(first, second) unless second.nil? or result.edge?(first, second) or result.edge?(second, first)
  end
  
  resources_with_dependencies.each do |r|
    
    r.dependencies.each do |dep_type, deps_array|
      deps_array.each do |dep_name|
        dep = get_resource(dep_type, dep_name)
        raise PoolPartyError.create("ResourceNotFound", "A resource required for #{dep_type}(#{dep_name}) was not found: #{dep_type}(#{dep_name}). Please make sure you've specified this in your configuration.") unless dep
        
        unless result.edge?(dep, r) and result.edge?(r, dep)
          existing_connections = result.adjacent(dep)
          existing_connections.each {|c| result.remove_edge!(r, c) }
          
          result.add_edge!(dep, r, dep.name)
          
          existing_connections.each {|c| result.add_edge!(dep, c) }
        end
        
      end
    end
  end
  
  all_resources.each_with_index do |resource, idx|
    if on
      result.add_edge!(resource, on, resource.name) unless result.edge?(resource, on) or result.edge?(on, resource)
    else
      result.add_vertex!(resource) unless result.vertex?(resource)
    end
  end
  
  result
end

#dependencies ⇒ Object

All the dependencies that are required by this resource This is a hash of the dependencies required by the resource



199
200
201
 
# File 'lib/poolparty/base.rb', line 199

def dependencies
  @dependencies ||= {}
end

#get_resource(ty, nm) ⇒ Object

Get a resource, based on it’s type Used for INTERNAL use



116
117
118
119
 
# File 'lib/poolparty/base.rb', line 116

def get_resource(ty, nm)
  o = self.send "#{ty}s".to_sym
  o.detect {|r| r.name == nm }
end

#has_searchable_paths(opts = {}) ⇒ Object 



243
244
245
246
247
248
249
250
251
252
253
 
# File 'lib/poolparty/base.rb', line 243

def has_searchable_paths(opts={})
  default_searchable_paths = [
    Dir.pwd,
    PoolParty::Default.poolparty_home_path,
    PoolParty::Default.poolparty_src_path,
    PoolParty::Default.poolparty_src_path/:lib/:poolparty,
    PoolParty::Default.base_config_directory,
    PoolParty::Default.remote_storage_path
  ]
  super(opts.merge(:paths => (opts.delete(:paths) || default_searchable_paths)))
end

#ordered_resources ⇒ Object

Order the resources_graph using a top-sort iterator



110
111
112
 
# File 'lib/poolparty/base.rb', line 110

def ordered_resources
  resources_graph.topsort.to_a
end

#output_resources_graph(fmt = 'png', dotfile = name, params = {}) ⇒ Object

Write the cloud dependency graph



210
211
212
213
214
215
216
217
218
219
220
221
222
223
 
# File 'lib/poolparty/base.rb', line 210

def output_resources_graph(fmt='png', dotfile=name, params={})
    p = {
      'bgcolor' => 'white',
      'label'   => "#{name}",
      'pad'     => '0.5',
      'rankdir' => 'LR',
      'overlap' => 'false',
      'node_params' => {
        'color' => '"#111111"',
        'style' => "rounded"
      }
    }.merge(params)
    resources_graph.write_to_graphic_file(fmt, dotfile, p)
end

#resources ⇒ Object

Resources are all the resources attached to this resource



105
106
107
 
# File 'lib/poolparty/base.rb', line 105

def resources
  @resources ||= []
end

#resources_graph(force = false) ⇒ Object

Create a directed adjacency graph of each of the dependencies Add all the resources in order and their resources as well and then create the graph from the rest of the resources to create edges on the graph



129
130
131
132
133
134
135
136
 
# File 'lib/poolparty/base.rb', line 129

def resources_graph(force=false)
  return @resources_graph if @resources_graph && !force
  result = Digraph.new
  
  create_graph(resources, nil, result)
  
  @resources_graph = result
end

#resources_with_dependencies(r = all_resources) ⇒ Object 



193
194
195
 
# File 'lib/poolparty/base.rb', line 193

def resources_with_dependencies(r=all_resources)
  r - resources_without_dependencies(r)
end

#resources_without_dependencies(r = all_resources) ⇒ Object 



189
190
191
 
# File 'lib/poolparty/base.rb', line 189

def resources_without_dependencies(r=all_resources)
  r.reject {|a| !a.dependencies.empty? }
end

#run_in_context(o = {}, &block) ⇒ Object

Overloading the parent run_in_context First, push ourself to the stack then set all the variables given with the init and then eval the block and pop ourselves off the stack During runtime, the stack looks like

  • self

    • instance_eval block

  • stack



38
39
40
41
42
43
44
45
 
# File 'lib/poolparty/base.rb', line 38

def run_in_context(o={}, &block)
  proc = Proc.new do
    set_vars_from_options(:name => o[:name]) if o.has_key?(:name) # Name MUST be set first
    set_vars_from_options(o)
    instance_eval &block if block
  end
  super(&proc)
end

#run_with_callbacks(o, &block) ⇒ Object

Run the block in the context of self and call the block after calling

before_load

and afterwards calling

after_loaded



52
53
54
55
56
57
58
 
# File 'lib/poolparty/base.rb', line 52

def run_with_callbacks(o, &block)
  run_in_context(o) do
    callback :before_load, o, &block
    instance_eval &block if block
    callback :after_loaded, o, &block
  end
end

#to_s ⇒ Object 



121
122
123
 
# File 'lib/poolparty/base.rb', line 121

def to_s
  "#{self.respond_to?(:has_method_name) ? self.has_method_name : self.class.to_s.top_level_class}:#{name}"
end

#valid? ⇒ Boolean

Validation checks if all of the validations pass, the object is considered valid the validations are responsible for raising a PoolPartyError (StandardError)

Returns:

  • (Boolean) 


91
92
93
 
# File 'lib/poolparty/base.rb', line 91

def valid?
  validations.each {|validation| self.send(validation.to_sym) }
end

#validations ⇒ Object

The array of validations that the instances must pass to be considered valid. These must be methods available on the instance



97
98
99
 
# File 'lib/poolparty/base.rb', line 97

def validations
  []
end