Class: AWS::CloudFormation::Stack

Inherits:
Object
  • Object
show all
Defined in:
lib/aws-cloudformation-stack.rb

Instance Method Summary collapse

Constructor Details

#initialize(name, options = {}) ⇒ Stack

Returns a new instance of Stack.



10
11
12
13
14
15
16
17
18
19
20
21
22
 
# File 'lib/aws-cloudformation-stack.rb', line 10

def initialize name, options = {}
  @name = name
  
  @as = AWS::AutoScaling.new
  @cw = AWS::CloudWatch.new
  @ec2 = AWS::EC2.new
  @elb = AWS::ELB.new
  @iam = AWS::IAM.new
  @rds = AWS::RDS.new
  @s3 = AWS::S3.new

  super
end

Instance Method Details

#autoscaling_group(logical_id) ⇒ Object 



24
25
26
27
 
# File 'lib/aws-cloudformation-stack.rb', line 24

def autoscaling_group(logical_id)
  id = autoscaling_group_ids[logical_id.to_sym]
  @as.groups[id] if id
end

#autoscaling_group_ids ⇒ Object 



33
34
35
 
# File 'lib/aws-cloudformation-stack.rb', line 33

def autoscaling_group_ids
  get_resources "AWS::AutoScaling::AutoScalingGroup" 
end

#autoscaling_groups ⇒ Object 



29
30
31
 
# File 'lib/aws-cloudformation-stack.rb', line 29

def autoscaling_groups
  autoscaling_group_ids.inject({}) { |hash, (k,v)| hash[k] = autoscaling_group(k); hash }
end

#bucket(logical_id) ⇒ Object 



37
38
39
40
 
# File 'lib/aws-cloudformation-stack.rb', line 37

def bucket(logical_id)
  id = bucket_ids[logical_id.to_sym]
  @s3.buckets[id] if id
end

#bucket_ids ⇒ Object 



46
47
48
 
# File 'lib/aws-cloudformation-stack.rb', line 46

def bucket_ids
  get_resources "AWS::S3::Bucket"
end

#buckets ⇒ Object 



42
43
44
 
# File 'lib/aws-cloudformation-stack.rb', line 42

def buckets
  bucket_ids.inject({}) { |hash, (k,v)| hash[k] = bucket(k); hash }
end

#cloudwatch_alarm(logical_id) ⇒ Object 



50
51
52
53
 
# File 'lib/aws-cloudformation-stack.rb', line 50

def cloudwatch_alarm(logical_id)
  id = cloudwatch_alarm_ids[logical_id.to_sym]
  @cw.alarms[id] if id
end

#cloudwatch_alarm_ids ⇒ Object 



59
60
61
 
# File 'lib/aws-cloudformation-stack.rb', line 59

def cloudwatch_alarm_ids
  get_resources "AWS::CloudWatch::Alarm"
end

#cloudwatch_alarms ⇒ Object 



55
56
57
 
# File 'lib/aws-cloudformation-stack.rb', line 55

def cloudwatch_alarms
  cloudwatch_alarm_ids.inject({}) { |hash, (k,v)| hash[k] = cloudwatch_alarm(k); hash }
end

#db_instance(logical_id) ⇒ Object 



63
64
65
 
# File 'lib/aws-cloudformation-stack.rb', line 63

def db_instance(logical_id)
  AWS::RDS.new.db_instances[db_instance_ids[logical_id.to_sym]]
end

#db_instance_ids ⇒ Object 



71
72
73
 
# File 'lib/aws-cloudformation-stack.rb', line 71

def db_instance_ids
  get_resources "AWS::RDS::DBInstance"
end

#db_instances ⇒ Object 



67
68
69
 
# File 'lib/aws-cloudformation-stack.rb', line 67

def db_instances
  db_instance_ids.inject({}) { |hash, (k,v)| hash[k] = db_instance(k); hash }
end

#eip(logical_id) ⇒ Object Also known as: elastic_ip 



75
76
77
78
 
# File 'lib/aws-cloudformation-stack.rb', line 75

def eip(logical_id)
  id = eip_ids[logical_id.to_sym]
  @ec2.elastic_ips[id] if id
end

#eip_ids ⇒ Object 



88
89
90
 
# File 'lib/aws-cloudformation-stack.rb', line 88

def eip_ids
  get_resources "AWS::EC2::EIP"
end

#eips ⇒ Object Also known as: elastic_ips 



82
83
84
 
# File 'lib/aws-cloudformation-stack.rb', line 82

def eips
  eip_ids.inject({}) { |hash, (k,v)| hash[k] = eip(k) }
end

#elb(logical_id) ⇒ Object 



92
93
94
95
 
# File 'lib/aws-cloudformation-stack.rb', line 92

def elb(logical_id)
  id = elb_ids[logical_id.to_sym]
  @elb.load_balancers[id] if id
end

#elb_ids ⇒ Object 



101
102
103
 
# File 'lib/aws-cloudformation-stack.rb', line 101

def elb_ids
  get_resources "AWS::ElasticLoadBalancing::LoadBalancer"
end

#elbs ⇒ Object 



97
98
99
 
# File 'lib/aws-cloudformation-stack.rb', line 97

def elbs
  elb_ids.inject({}) { |hash, (k,v)| hash[k] = elb(k); hash }
end

#iam_access_key(user_logical_id, key_logical_id) ⇒ Object 



105
106
107
108
109
110
111
112
113
 
# File 'lib/aws-cloudformation-stack.rb', line 105

def iam_access_key(user_logical_id, key_logical_id)
  id = iam_access_key_ids[key_logical_id.to_sym]
  user = iam_user(user_logical_id)
  if (id && user)
    user.access_keys[id]
  else
    nil
  end
end

#iam_access_key_ids ⇒ Object 



115
116
117
 
# File 'lib/aws-cloudformation-stack.rb', line 115

def iam_access_key_ids
  get_resources "AWS::IAM::AccessKey"
end

#iam_group(logical_id) ⇒ Object 



119
120
121
122
 
# File 'lib/aws-cloudformation-stack.rb', line 119

def iam_group(logical_id)
  id = iam_group_ids[logical_id.to_sym]
  @iam.groups[id] if id
end

#iam_group_ids ⇒ Object 



128
129
130
 
# File 'lib/aws-cloudformation-stack.rb', line 128

def iam_group_ids
  get_resources "AWS::IAM::Group"
end

#iam_groups ⇒ Object 



124
125
126
 
# File 'lib/aws-cloudformation-stack.rb', line 124

def iam_groups
  iam_group_ids.inject({}) { |hash, (k,v)| hash[k] = iam_group(k); hash }
end

#iam_policy ⇒ Object Also known as: iam_policies 



132
133
134
 
# File 'lib/aws-cloudformation-stack.rb', line 132

def iam_policy
 puts "use Stack.iam_group#policies or Stack.iam_user#policies"
end

#iam_policy_ids ⇒ Object 



138
139
140
 
# File 'lib/aws-cloudformation-stack.rb', line 138

def iam_policy_ids
  get_resources "AWS::IAM::Policy"
end

#iam_user(logical_id) ⇒ Object 



142
143
144
145
 
# File 'lib/aws-cloudformation-stack.rb', line 142

def iam_user(logical_id)
  id = iam_user_ids[logical_id.to_sym]
  @iam.users[id] if id
end

#iam_user_ids ⇒ Object 



151
152
153
 
# File 'lib/aws-cloudformation-stack.rb', line 151

def iam_user_ids
  get_resources "AWS::IAM::User"
end

#iam_users ⇒ Object 



147
148
149
 
# File 'lib/aws-cloudformation-stack.rb', line 147

def iam_users
  iam_user_ids.inject({}) { |hash, (k,v)| hash[k] = iam_user(k); hash }
end

#instance(logical_id) ⇒ Object 



155
156
157
158
 
# File 'lib/aws-cloudformation-stack.rb', line 155

def instance(logical_id)
  id = instance_ids[logical_id.to_sym]
  @ec2.instances[id] if id
end

#instance_ids ⇒ Object 



164
165
166
 
# File 'lib/aws-cloudformation-stack.rb', line 164

def instance_ids
  get_resources "AWS::EC2::Instance"
end

#instances ⇒ Object 



160
161
162
 
# File 'lib/aws-cloudformation-stack.rb', line 160

def instances
  instance_ids.inject({}) { |hash, (k,v)| hash[k] = instance(k); hash }
end

#internet_gateway(logical_id) ⇒ Object Also known as: igw 



168
169
170
171
 
# File 'lib/aws-cloudformation-stack.rb', line 168

def internet_gateway(logical_id)
  id = internet_gateway_ids[logical_id.to_sym]
  @ec2.internet_gateways[id] if id
end

#internet_gateway_ids ⇒ Object 



175
176
177
 
# File 'lib/aws-cloudformation-stack.rb', line 175

def internet_gateway_ids
  get_resources "AWS::EC2::InternetGateway"
end

#launch_configuration(logical_id) ⇒ Object Also known as: launch_config 



179
180
181
182
 
# File 'lib/aws-cloudformation-stack.rb', line 179

def launch_configuration(logical_id)
  id = launch_configuration_ids[logical_id.to_sym]
  @as.launch_configurations[id] if id
end

#launch_configuration_ids ⇒ Object 



192
193
194
 
# File 'lib/aws-cloudformation-stack.rb', line 192

def launch_configuration_ids
  get_resources "AWS::AutoScaling::LaunchConfiguration"
end

#launch_configurations ⇒ Object Also known as: launch_configs 



186
187
188
 
# File 'lib/aws-cloudformation-stack.rb', line 186

def launch_configurations
  launch_configuration_ids.inject({}) { |hash, (k,v)| hash[k] = launch_configuration(k); hash }
end

#network_interface(logical_id) ⇒ Object Also known as: nic 



196
197
198
199
 
# File 'lib/aws-cloudformation-stack.rb', line 196

def network_interface(logical_id)
  id = network_interface_ids[logical_id.to_sym]
  @ec2.network_interfaces[id] if id
end

#network_interface_ids ⇒ Object 



209
210
211
 
# File 'lib/aws-cloudformation-stack.rb', line 209

def network_interface_ids
  get_resources "AWS::EC2::NetworkInterface"
end

#network_interfaces ⇒ Object Also known as: nics 



203
204
205
 
# File 'lib/aws-cloudformation-stack.rb', line 203

def network_interfaces
  network_interface_ids.inject({}) { |hash, (k,v)| hash[k] = network_interface(k); hash }
end

#route_table(logical_id) ⇒ Object 



213
214
215
216
 
# File 'lib/aws-cloudformation-stack.rb', line 213

def route_table(logical_id)
  id = route_table_ids[logical_id.to_sym]
  @ec2.route_tables[id] if id
end

#route_table_ids ⇒ Object 



218
219
220
 
# File 'lib/aws-cloudformation-stack.rb', line 218

def route_table_ids
  get_resources "AWS::EC2::RouteTable"
end

#scaling_policies(as_group_logical_id) ⇒ Object 



233
234
235
 
# File 'lib/aws-cloudformation-stack.rb', line 233

def scaling_policies(as_group_logical_id)
  scaling_policy_ids.inject({}) { |hash, (k,v)| hash[k] = scaling_policy(as_group_logical_id,k.to_s); hash }
end

#scaling_policy(as_group_logical_id, policy_logical_id) ⇒ Object 



222
223
224
225
226
227
228
229
230
231
 
# File 'lib/aws-cloudformation-stack.rb', line 222

def scaling_policy(as_group_logical_id, policy_logical_id)
  group = autoscaling_group(as_group_logical_id)
  id = scaling_policy_ids[policy_logical_id.to_sym]
  policy = id.split('/')[-1] unless id.nil?
  if (group && policy)
    AWS::AutoScaling::ScalingPolicy.new(group, policy)
  else
    nil
  end
end

#scaling_policy_ids ⇒ Object 



237
238
239
 
# File 'lib/aws-cloudformation-stack.rb', line 237

def scaling_policy_ids
  get_resources "AWS::AutoScaling::ScalingPolicy"
end

#security_group(logical_id) ⇒ Object 



241
242
243
244
 
# File 'lib/aws-cloudformation-stack.rb', line 241

def security_group(logical_id)
  id = security_group_ids[logical_id.to_sym]
  @ec2.security_groups.filter('group-id',id).first if id
end

#security_group_ids ⇒ Object 



250
251
252
 
# File 'lib/aws-cloudformation-stack.rb', line 250

def security_group_ids
  get_resources "AWS::EC2::SecurityGroup"
end

#security_groups ⇒ Object 



246
247
248
 
# File 'lib/aws-cloudformation-stack.rb', line 246

def security_groups
  security_group_ids.inject({}) { |hash, (k,v)| hash[k] = security_group(k); hash }
end

#subnet(logical_id) ⇒ Object 



254
255
256
257
 
# File 'lib/aws-cloudformation-stack.rb', line 254

def subnet(logical_id)
  id = subnet_ids[logical_id.to_sym]
  @ec2.subnets[id] if id
end

#subnet_ids ⇒ Object 



263
264
265
 
# File 'lib/aws-cloudformation-stack.rb', line 263

def subnet_ids
  get_resources "AWS::EC2::Subnet"
end

#subnets ⇒ Object 



259
260
261
 
# File 'lib/aws-cloudformation-stack.rb', line 259

def subnets
  subnet_ids.inject({}) { |hash, (k,v)| hash[k] = subnet(k); hash }
end

#volume(logical_id) ⇒ Object 



267
268
269
270
 
# File 'lib/aws-cloudformation-stack.rb', line 267

def volume(logical_id)
  id = volume_ids[logical_id.to_sym]
  @ec2.volumes[id] if id
end

#volume_ids ⇒ Object 



276
277
278
 
# File 'lib/aws-cloudformation-stack.rb', line 276

def volume_ids
  get_resources "AWS::EC2::Volume"
end

#volumes ⇒ Object 



272
273
274
 
# File 'lib/aws-cloudformation-stack.rb', line 272

def volumes
  volume_ids.inject({}) { |hash, (k,v)| hash[k] = volume(k); hash }
end

#vpc(logical_id) ⇒ Object 



280
281
282
283
 
# File 'lib/aws-cloudformation-stack.rb', line 280

def vpc(logical_id)
  id = vpc_ids[logical_id.to_sym]
  @ec2.vpcs[id] if id
end

#vpc_ids ⇒ Object 



289
290
291
 
# File 'lib/aws-cloudformation-stack.rb', line 289

def vpc_ids
  get_resources "AWS::EC2::VPC"
end

#vpcs ⇒ Object 



285
286
287
 
# File 'lib/aws-cloudformation-stack.rb', line 285

def vpcs
  vpc_ids.inject({}) { |hash, (k,v)| hash[k] = vpc(k); hash }
end