Merging in latest boto.

boto/ec2/instance.py

 # Copyright (c) 2006-2010 Mitch Garnaat http://garnaat.org/
 # Copyright (c) 2010, Eucalyptus Systems, Inc.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
 # copy of this software and associated documentation files (the
 # "Software"), to deal in the Software without restriction, including
 # without limitation the rights to use, copy, modify, merge, publish, dis-
 # tribute, sublicense, and/or sell copies of the Software, and to permit
 # persons to whom the Software is furnished to do so, subject to the fol-
 # lowing conditions:
@@ skipping 14 matching lines @@
 """
 import boto
 from boto.ec2.ec2object import EC2Object, TaggedEC2Object
 from boto.resultset import ResultSet
 from boto.ec2.address import Address
 from boto.ec2.blockdevicemapping import BlockDeviceMapping
 from boto.ec2.image import ProductCodes
 import base64
 
 class Reservation(EC2Object):
+    """
+    Represents a Reservation response object.
+
+    :ivar id: The unique ID of the Reservation.
+    :ivar owner_id: The unique ID of the owner of the Reservation.
+    :ivar groups: A list of Group objects representing the security
+                  groups associated with launched instances.
+    :ivar instances: A list of Instance objects launched in this
+                     Reservation.
+    """
     
     def __init__(self, connection=None):
         EC2Object.__init__(self, connection)
         self.id = None
         self.owner_id = None
         self.groups = []
         self.instances = []
 
     def __repr__(self):
         return 'Reservation:%s' % self.id
@@ skipping 51 matching lines @@
         self.ip_address = None
         self.requester_id = None
         self._in_monitoring_element = False
         self.persistent = False
         self.root_device_name = None
         self.root_device_type = None
         self.block_device_mapping = None
         self.state_reason = None
         self.group_name = None
         self.client_token = None
+        self.groups = []
 
     def __repr__(self):
         return 'Instance:%s' % self.id
 
     def startElement(self, name, attrs, connection):
         retval = TaggedEC2Object.startElement(self, name, attrs, connection)
         if retval is not None:
             return retval
         if name == 'monitoring':
             self._in_monitoring_element = True
         elif name == 'blockDeviceMapping':
             self.block_device_mapping = BlockDeviceMapping()
             return self.block_device_mapping
         elif name == 'productCodes':
             return self.product_codes
         elif name == 'stateReason':
             self.state_reason = StateReason()
             return self.state_reason
+        elif name == 'groupSet':
+            self.groups = ResultSet([('item', Group)])
+            return self.groups
         return None
 
     def endElement(self, name, value, connection):
         if name == 'instanceId':
             self.id = value
         elif name == 'imageId':
             self.image_id = value
         elif name == 'dnsName' or name == 'publicDnsName':
             self.dns_name = value           # backwards compatibility
             self.public_dns_name = value
@@ skipping 88 matching lines @@
                     self._update(i)
         elif validate:
             raise ValueError('%s is not a valid Instance ID' % self.id)
         return self.state
 
     def terminate(self):
         """
         Terminate the instance
         """
         rs = self.connection.terminate_instances([self.id])
-        self._update(rs[0])
+        if len(rs) > 0:
+            self._update(rs[0])
 
     def stop(self, force=False):
         """
         Stop the instance
 
         :type force: bool
         :param force: Forces the instance to stop
         
         :rtype: list
         :return: A list of the instances stopped
         """
         rs = self.connection.stop_instances([self.id])
-        self._update(rs[0])
+        if len(rs) > 0:
+            self._update(rs[0])
 
     def start(self):
         """
         Start the instance.
         """
         rs = self.connection.start_instances([self.id])
-        self._update(rs[0])
+        if len(rs) > 0:
+            self._update(rs[0])
 
     def reboot(self):
         return self.connection.reboot_instances([self.id])
 
     def get_console_output(self):
         """
         Retrieves the console output for the instance.
 
         :rtype: :class:`boto.ec2.instance.ConsoleOutput`
         :return: The console output as a ConsoleOutput object
@@ skipping 66 matching lines @@
 
         :rtype: bool
         :return: Whether the operation succeeded or not
         """
         return self.connection.reset_instance_attribute(self.id, attribute)
 
 class Group:
 
     def __init__(self, parent=None):
         self.id = None
+        self.name = None
 
     def startElement(self, name, attrs, connection):
         return None
 
     def endElement(self, name, value, connection):
         if name == 'groupId':
             self.id = value
+        elif name == 'groupName':
+            self.name = value
         else:
             setattr(self, name, value)
     
 class ConsoleOutput:
 
     def __init__(self, parent=None):
         self.parent = parent
         self.instance_id = None
         self.timestamp = None
-        self.comment = None
+        self.output = None
 
     def startElement(self, name, attrs, connection):
         return None
 
     def endElement(self, name, value, connection):
         if name == 'instanceId':
             self.instance_id = value
+        elif name == 'timestamp':
+            self.timestamp = value
         elif name == 'output':
             self.output = base64.b64decode(value)
         else:
             setattr(self, name, value)
 
 class InstanceAttribute(dict):
 
+    ValidValues = ['instanceType', 'kernel', 'ramdisk', 'userData',
+                   'disableApiTermination', 'instanceInitiatedShutdownBehavior',
+                   'rootDeviceName', 'blockDeviceMapping', 'sourceDestCheck',
+                   'groupSet']
+
     def __init__(self, parent=None):
         dict.__init__(self)
+        self.instance_id = None
+        self.request_id = None
         self._current_value = None
 
     def startElement(self, name, attrs, connection):
-        return None
+        if name == 'blockDeviceMapping':
+            self[name] = BlockDeviceMapping()
+            return self[name]
+        elif name == 'groupSet':
+            self[name] = ResultSet([('item', Group)])
+            return self[name]
+        else:
+            return None
 
     def endElement(self, name, value, connection):
-        if name == 'value':
+        if name == 'instanceId':
+            self.instance_id = value
+        elif name == 'requestId':
+            self.request_id = value
+        elif name == 'value':
             self._current_value = value
-        else:
+        elif name in self.ValidValues:
             self[name] = self._current_value
 
 class StateReason(dict):
 
     def __init__(self, parent=None):
         dict.__init__(self)
 
     def startElement(self, name, attrs, connection):
         return None
 
     def endElement(self, name, value, connection):
         if name != 'stateReason':
             self[name] = value