Class: Jets::Stack

Inherits:
Object
  • Object
show all
Extended by:
Memoist
Includes:
Main::Dsl, Output::Dsl, Parameter::Dsl, Resource::Dsl
Defined in:
lib/jets/stack/output.rb,
lib/jets/stack.rb,
lib/jets/stack/main.rb,
lib/jets/stack/builder.rb,
lib/jets/stack/depends.rb,
lib/jets/stack/function.rb,
lib/jets/stack/main/dsl.rb,
lib/jets/stack/resource.rb,
lib/jets/stack/s3_event.rb,
lib/jets/stack/parameter.rb,
lib/jets/stack/definition.rb,
lib/jets/stack/output/dsl.rb,
lib/jets/stack/resource/dsl.rb,
lib/jets/stack/parameter/dsl.rb

Overview

Class that include Definition should implement:

template - method should use @definition to build a CloudFormation template section

Defined Under Namespace

Modules: Definition Classes: Builder, Depends, Function, Main, Output, Parameter, Resource, S3Event

Class Method Summary collapse

Methods included from Resource::Dsl

#resources

Methods included from Output::Dsl

#outputs

Methods included from Parameter::Dsl

#add_common_parameters, #add_depends_on_parameters, #dependency_outputs, #parameters

Methods included from Main::Dsl

included

Class Method Details

.build? ⇒ Boolean

Build it to figure out if we need to build the stack for the SharedBuilder

Returns:

  • (Boolean) 


46
47
48
49
 
# File 'lib/jets/stack.rb', line 46

def build?
  empty = template == {"Parameters"=>{"IamRole"=>{"Type"=>"String"}, "S3Bucket"=>{"Type"=>"String"}}}
  !empty
end

.eager_load_shared_resources! ⇒ Object 



90
91
92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/jets/stack.rb', line 90

def eager_load_shared_resources!
  ActiveSupport::Dependencies.autoload_paths += ["#{Jets.root}/app/shared/resources"]
  Dir.glob("#{Jets.root}/app/shared/resources/**/*.rb").select do |path|
    next if !File.file?(path) or path =~ %r{/javascript/} or path =~ %r{/views/}

    class_name = path
                  .sub(/\.rb$/,'') # remove .rb
                  .sub("#{Jets.root}/",'') # remove ./
                  .sub(%r{app/shared/resources/},'') # remove app/shared/resources/
                  .classify
    class_name.constantize # use constantize instead of require so dont have to worry about order.
  end
end

.functions ⇒ Object 



51
52
53
54
55
56
57
58
59
60
 
# File 'lib/jets/stack.rb', line 51

def functions
  stack = new
  # All the & because resources might be nil
  templates = stack.resources&.map(&:template)&.select do |t|
    attributes = t.values.first
    attributes['Type'] == 'AWS::Lambda::Function'
  end
  templates ||= []
  templates.map { |t| Function.new(t) }
end

.has_resources? ⇒ Boolean

Usage:

Jets::Stack.has_resources?

Returns:

  • (Boolean) 


82
83
84
 
# File 'lib/jets/stack.rb', line 82

def has_resources?
  !subclasses.empty?
end

.inherited(base) ⇒ Object 



26
27
28
29
 
# File 'lib/jets/stack.rb', line 26

def inherited(base)
  super
  self.subclasses << base if base.name
end

.looker ⇒ Object 



108
109
110
 
# File 'lib/jets/stack.rb', line 108

def looker
  Jets::Stack::Output::Lookup.new(self)
end

.lookup(logical_id) ⇒ Object 



104
105
106
 
# File 'lib/jets/stack.rb', line 104

def lookup(logical_id)
  looker.output(logical_id)
end

.new_class(class_name, &block) ⇒ Object

klass = Jets::Stack.new_class(“Bucket3”)



32
33
34
35
36
37
38
39
40
41
42
43
 
# File 'lib/jets/stack.rb', line 32

def new_class(class_name, &block)
  # https://stackoverflow.com/questions/4113479/dynamic-class-definition-with-a-class-name
  # Defining the constant this way gets around: SyntaxError: dynamic constant assignment error
  klass = Class.new(Jets::Stack) # First klass is an anonymous class. IE: class.name is nil
  klass = Object.const_set(class_name, klass) # now klass is a named class
  Jets::Stack.subclasses << klass # mimic inherited hook because

  # Must run class_eval after adding to subclasses in order for the resource declarations in the
  # so that the resources get registered to the right subclass.
  klass.class_eval(&block)
  klass # return klass
end

.output_keys ⇒ Object 



113
114
115
116
 
# File 'lib/jets/stack.rb', line 113

def output_keys
  outputs = new.outputs || []
  outputs.map(&:template).map {|o| o.keys.first}
end

.subclasses ⇒ Object

Track all command subclasses.



22
23
24
 
# File 'lib/jets/stack.rb', line 22

def subclasses
  @subclasses ||= []
end

.template ⇒ Object 



62
63
64
65
66
67
68
69
70
71
 
# File 'lib/jets/stack.rb', line 62

def template
  # Pretty funny looking, creating an instance of stack to be passed to the Builder.
  # Another way of looking at it:
  #
  #   stack = new # MyStack.new
  #   builder = Jets::Stack::Builder.new(stack)
  #
  builder = Jets::Stack::Builder.new(new)
  builder.template
end