← Back to branch summary

~ntt-pf-lab/nova/monkey_patch_notification

« back to all changes in this revision

Viewing changes to vendor/boto/boto/ec2/instance.py

  • Committer: Jesse Andrews
  • Date: 2010-05-28 06:05:26 UTC
  • Revision ID: git-v1:bf6e6e718cdc7488e2da87b21e258ccc065fe499
initial commit

Show diffs side-by-side

added added

removed removed

Lines of Context:
vendor/boto/boto/ec2/instance.py
 
1
# Copyright (c) 2006-2008 Mitch Garnaat http://garnaat.org/
 
2
#
 
3
# Permission is hereby granted, free of charge, to any person obtaining a
 
4
# copy of this software and associated documentation files (the
 
5
# "Software"), to deal in the Software without restriction, including
 
6
# without limitation the rights to use, copy, modify, merge, publish, dis-
 
7
# tribute, sublicense, and/or sell copies of the Software, and to permit
 
8
# persons to whom the Software is furnished to do so, subject to the fol-
 
9
# lowing conditions:
 
10
#
 
11
# The above copyright notice and this permission notice shall be included
 
12
# in all copies or substantial portions of the Software.
 
13
#
 
14
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 
15
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
 
16
# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
 
17
# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
 
18
# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 
19
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 
20
# IN THE SOFTWARE.
 
21
 
 
22
"""
 
23
Represents an EC2 Instance
 
24
"""
 
25
import boto
 
26
from boto.ec2.ec2object import EC2Object
 
27
from boto.resultset import ResultSet
 
28
from boto.ec2.address import Address
 
29
from boto.ec2.blockdevicemapping import BlockDeviceMapping
 
30
from boto.ec2.image import ProductCodes
 
31
import base64
 
32
 
 
33
class Reservation(EC2Object):
 
34
    
 
35
    def __init__(self, connection=None):
 
36
        EC2Object.__init__(self, connection)
 
37
        self.id = None
 
38
        self.owner_id = None
 
39
        self.groups = []
 
40
        self.instances = []
 
41
 
 
42
    def __repr__(self):
 
43
        return 'Reservation:%s' % self.id
 
44
 
 
45
    def startElement(self, name, attrs, connection):
 
46
        if name == 'instancesSet':
 
47
            self.instances = ResultSet([('item', Instance)])
 
48
            return self.instances
 
49
        elif name == 'groupSet':
 
50
            self.groups = ResultSet([('item', Group)])
 
51
            return self.groups
 
52
        else:
 
53
            return None
 
54
 
 
55
    def endElement(self, name, value, connection):
 
56
        if name == 'reservationId':
 
57
            self.id = value
 
58
        elif name == 'ownerId':
 
59
            self.owner_id = value
 
60
        else:
 
61
            setattr(self, name, value)
 
62
 
 
63
    def stop_all(self):
 
64
        for instance in self.instances:
 
65
            instance.stop()
 
66
            
 
67
class Instance(EC2Object):
 
68
    
 
69
    def __init__(self, connection=None):
 
70
        EC2Object.__init__(self, connection)
 
71
        self.id = None
 
72
        self.dns_name = None
 
73
        self.public_dns_name = None
 
74
        self.private_dns_name = None
 
75
        self.state = None
 
76
        self.state_code = None
 
77
        self.key_name = None
 
78
        self.shutdown_state = None
 
79
        self.previous_state = None
 
80
        self.instance_type = None
 
81
        self.instance_class = None
 
82
        self.launch_time = None
 
83
        self.image_id = None
 
84
        self.placement = None
 
85
        self.kernel = None
 
86
        self.ramdisk = None
 
87
        self.product_codes = ProductCodes()
 
88
        self.ami_launch_index = None
 
89
        self.monitored = False
 
90
        self.instance_class = None
 
91
        self.spot_instance_request_id = None
 
92
        self.subnet_id = None
 
93
        self.vpc_id = None
 
94
        self.private_ip_address = None
 
95
        self.ip_address = None
 
96
        self.requester_id = None
 
97
        self._in_monitoring_element = False
 
98
        self.persistent = False
 
99
        self.root_device_name = None
 
100
        self.root_device_type = None
 
101
        self.block_device_mapping = None
 
102
        self.state_reason = None
 
103
 
 
104
    def __repr__(self):
 
105
        return 'Instance:%s' % self.id
 
106
 
 
107
    def startElement(self, name, attrs, connection):
 
108
        if name == 'monitoring':
 
109
            self._in_monitoring_element = True
 
110
        elif name == 'blockDeviceMapping':
 
111
            self.block_device_mapping = BlockDeviceMapping()
 
112
            return self.block_device_mapping
 
113
        elif name == 'productCodes':
 
114
            return self.product_codes
 
115
        elif name == 'stateReason':
 
116
            self.state_reason = StateReason()
 
117
            return self.state_reason
 
118
        return None
 
119
 
 
120
    def endElement(self, name, value, connection):
 
121
        if name == 'instanceId':
 
122
            self.id = value
 
123
        elif name == 'imageId':
 
124
            self.image_id = value
 
125
        elif name == 'dnsName' or name == 'publicDnsName':
 
126
            self.dns_name = value           # backwards compatibility
 
127
            self.public_dns_name = value
 
128
        elif name == 'privateDnsName':
 
129
            self.private_dns_name = value
 
130
        elif name == 'keyName':
 
131
            self.key_name = value
 
132
        elif name == 'amiLaunchIndex':
 
133
            self.ami_launch_index = value
 
134
        elif name == 'shutdownState':
 
135
            self.shutdown_state = value
 
136
        elif name == 'previousState':
 
137
            self.previous_state = value
 
138
        elif name == 'name':
 
139
            self.state = value
 
140
        elif name == 'code':
 
141
            try:
 
142
                self.state_code = int(value)
 
143
            except ValueError:
 
144
                boto.log.warning('Error converting code (%s) to int' % value)
 
145
                self.state_code = value
 
146
        elif name == 'instanceType':
 
147
            self.instance_type = value
 
148
        elif name == 'instanceClass':
 
149
            self.instance_class = value
 
150
        elif name == 'rootDeviceName':
 
151
            self.root_device_name = value
 
152
        elif name == 'rootDeviceType':
 
153
            self.root_device_type = value
 
154
        elif name == 'launchTime':
 
155
            self.launch_time = value
 
156
        elif name == 'availabilityZone':
 
157
            self.placement = value
 
158
        elif name == 'placement':
 
159
            pass
 
160
        elif name == 'kernelId':
 
161
            self.kernel = value
 
162
        elif name == 'ramdiskId':
 
163
            self.ramdisk = value
 
164
        elif name == 'state':
 
165
            if self._in_monitoring_element:
 
166
                if value == 'enabled':
 
167
                    self.monitored = True
 
168
                self._in_monitoring_element = False
 
169
        elif name == 'instanceClass':
 
170
            self.instance_class = value
 
171
        elif name == 'spotInstanceRequestId':
 
172
            self.spot_instance_request_id = value
 
173
        elif name == 'subnetId':
 
174
            self.subnet_id = value
 
175
        elif name == 'vpcId':
 
176
            self.vpc_id = value
 
177
        elif name == 'privateIpAddress':
 
178
            self.private_ip_address = value
 
179
        elif name == 'ipAddress':
 
180
            self.ip_address = value
 
181
        elif name == 'requesterId':
 
182
            self.requester_id = value
 
183
        elif name == 'persistent':
 
184
            if value == 'true':
 
185
                self.persistent = True
 
186
            else:
 
187
                self.persistent = False
 
188
        else:
 
189
            setattr(self, name, value)
 
190
 
 
191
    def _update(self, updated):
 
192
        self.__dict__.update(updated.__dict__)
 
193
 
 
194
    def update(self):
 
195
        rs = self.connection.get_all_instances([self.id])
 
196
        if len(rs) > 0:
 
197
            r = rs[0]
 
198
            for i in r.instances:
 
199
                if i.id == self.id:
 
200
                    self._update(i)
 
201
        return self.state
 
202
 
 
203
    def terminate(self):
 
204
        rs = self.connection.terminate_instances([self.id])
 
205
        self._update(rs[0])
 
206
 
 
207
    def stop(self):
 
208
        rs = self.connection.stop_instances([self.id])
 
209
        self._update(rs[0])
 
210
 
 
211
    def start(self):
 
212
        rs = self.connection.start_instances([self.id])
 
213
        self._update(rs[0])
 
214
 
 
215
    def reboot(self):
 
216
        return self.connection.reboot_instances([self.id])
 
217
 
 
218
    def get_console_output(self):
 
219
        return self.connection.get_console_output(self.id)
 
220
 
 
221
    def confirm_product(self, product_code):
 
222
        return self.connection.confirm_product_instance(self.id, product_code)
 
223
 
 
224
    def use_ip(self, ip_address):
 
225
        if isinstance(ip_address, Address):
 
226
            ip_address = ip_address.public_ip
 
227
        return self.connection.associate_address(self.id, ip_address)
 
228
 
 
229
    def monitor(self):
 
230
        return self.connection.monitor_instance(self.id)
 
231
 
 
232
    def unmonitor(self):
 
233
        return self.connection.unmonitor_instance(self.id)
 
234
 
 
235
class Group:
 
236
 
 
237
    def __init__(self, parent=None):
 
238
        self.id = None
 
239
 
 
240
    def startElement(self, name, attrs, connection):
 
241
        return None
 
242
 
 
243
    def endElement(self, name, value, connection):
 
244
        if name == 'groupId':
 
245
            self.id = value
 
246
        else:
 
247
            setattr(self, name, value)
 
248
    
 
249
class ConsoleOutput:
 
250
 
 
251
    def __init__(self, parent=None):
 
252
        self.parent = parent
 
253
        self.instance_id = None
 
254
        self.timestamp = None
 
255
        self.comment = None
 
256
 
 
257
    def startElement(self, name, attrs, connection):
 
258
        return None
 
259
 
 
260
    def endElement(self, name, value, connection):
 
261
        if name == 'instanceId':
 
262
            self.instance_id = value
 
263
        elif name == 'output':
 
264
            self.output = base64.b64decode(value)
 
265
        else:
 
266
            setattr(self, name, value)
 
267
 
 
268
class InstanceAttribute(dict):
 
269
 
 
270
    def __init__(self, parent=None):
 
271
        dict.__init__(self)
 
272
        self._current_value = None
 
273
 
 
274
    def startElement(self, name, attrs, connection):
 
275
        return None
 
276
 
 
277
    def endElement(self, name, value, connection):
 
278
        if name == 'value':
 
279
            self._current_value = value
 
280
        else:
 
281
            self[name] = self._current_value
 
282
 
 
283
class StateReason(dict):
 
284
 
 
285
    def __init__(self, parent=None):
 
286
        dict.__init__(self)
 
287
 
 
288
    def startElement(self, name, attrs, connection):
 
289
        return None
 
290
 
 
291
    def endElement(self, name, value, connection):
 
292
        if name != 'stateReason':
 
293
            self[name] = value
 
294