Class: StackMate::Stacker

Inherits:
Object
  • Object
show all
Includes:
Logging, TSort
Defined in:
lib/stackmate/stack.rb

Direct Known Subclasses

StackExecutor

Instance Method Summary collapse

Methods included from Logging

configure_logger_for, #logger, logger_for

Constructor Details

#initialize(templatefile, stackname, params) ⇒ Stacker

Returns a new instance of Stacker.



12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
# File 'lib/stackmate/stack.rb', line 12

def initialize(templatefile, stackname, params)
    @stackname = stackname
    @resolved = {}
    stackstr = File.read(templatefile)
    @templ = JSON.parse(stackstr) 
    @templ['StackName'] = @stackname
    @param_names = @templ['Parameters']
    @deps = {}
    @pdeps = {}
    resolve_param_refs(params)
    validate_param_values
    resolve_dependencies()
    @templ['ResolvedNames'] = @resolved
end

Instance Method Details

#find_refs(parent, jsn, deps, pdeps) ⇒ Object 



65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
 
# File 'lib/stackmate/stack.rb', line 65

def find_refs (parent, jsn, deps, pdeps)
    case jsn
        when Array
            jsn.each {|x| find_refs(parent, x, deps, pdeps)}
            #print parent, ": ", jsn, "\n"
        when Hash
            jsn.keys.each do |k|
                #TODO Fn::GetAtt
                if k == "Ref"
                    #only resolve dependencies on other resources for now
                    if !@param_names.keys.index(jsn[k]) && jsn[k] != 'AWS::Region' && jsn[k] != 'AWS::StackId'
                        deps << jsn[k]
                        #print parent, ": ", deps.to_a, "\n"
                    else if @param_names.keys.index(jsn[k])
                        pdeps << jsn[k]
                    end
                    end
                else
                    find_refs(parent, jsn[k], deps, pdeps)
                end
            end
    end
    return deps
end

#resolve_dependencies ⇒ Object 



40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/stackmate/stack.rb', line 40

def resolve_dependencies
    @templ['Resources'].each { |key,val| 
        deps = Set.new
        pdeps = Set.new
        find_refs(key, val, deps, pdeps)
        deps << val['DependsOn'] if val['DependsOn']
        #print key, " depends on ", deps.to_a, "\n"
        @deps[key] = deps.to_a
        @pdeps[key] = pdeps.to_a
    }
    @pdeps.keys.each do |k|
        unres = @pdeps[k] - @resolved.keys
        if ! unres.empty?
            unres.each do |u|
                deflt = @param_names[u]['Default']
                #print "Found default value ", deflt, " for ", u, "\n" if deflt
                @resolved[u] = deflt if deflt
            end
            unres = @pdeps[k] - @resolved.keys
            throw :unresolved, (@pdeps[k] - @resolved.keys) if !unres.empty?
        end
    end
end

#resolve_param_refs(params) ⇒ Object 



27
28
29
30
31
32
33
 
# File 'lib/stackmate/stack.rb', line 27

def resolve_param_refs(params)
    params.split(';').each do |p|
       i = p.split('=')
       @resolved[i[0]] = i[1]
    end
    @resolved['AWS::Region'] = 'us-east-1' #TODO handle this better
end

#tsort_each_child(name, &block) ⇒ Object 



94
95
96
 
# File 'lib/stackmate/stack.rb', line 94

def tsort_each_child(name, &block)
    @deps[name].each(&block) if @deps.has_key?(name)
end

#tsort_each_node(&block) ⇒ Object 



90
91
92
 
# File 'lib/stackmate/stack.rb', line 90

def tsort_each_node(&block)
    @deps.each_key(&block)
end

#validate_param_values ⇒ Object 



35
36
37
38
 
# File 'lib/stackmate/stack.rb', line 35

def validate_param_values
    #TODO CloudFormation parameters have validity constraints specified
    #Use them to validate parameter values (e.g., email addresses)
end