Merging in latest boto.

boto/utils.py

 # Copyright (c) 2006-2010 Mitch Garnaat http://garnaat.org/
 # Copyright (c) 2010, Eucalyptus Systems, Inc.
 # All rights reserved.
 #
 # 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-
@@ skipping 36 matching lines @@
 import logging.handlers
 import boto
 import tempfile
 import smtplib
 import datetime
 from email.MIMEMultipart import MIMEMultipart
 from email.MIMEBase import MIMEBase
 from email.MIMEText import MIMEText
 from email.Utils import formatdate
 from email import Encoders
+import gzip
+
 
 try:
     import hashlib
     _hashfn = hashlib.sha512
 except ImportError:
     import md5
     _hashfn = md5.md5
 
 # List of Query String Arguments of Interest
 qsa_of_interest = ['acl', 'location', 'logging', 'partNumber', 'policy',
@@ skipping 75 matching lines @@
     return final_headers
 
 def get_aws_metadata(headers, provider=None):
     if not provider:
         provider = boto.provider.get_default()
     metadata_prefix = provider.metadata_prefix
     metadata = {}
     for hkey in headers.keys():
         if hkey.lower().startswith(metadata_prefix):
             val = urllib.unquote_plus(headers[hkey])
-            metadata[hkey[len(metadata_prefix):]] = unicode(val, 'utf-8')
+            try:
+                metadata[hkey[len(metadata_prefix):]] = unicode(val, 'utf-8')
+            except UnicodeDecodeError:
+                metadata[hkey[len(metadata_prefix):]] = val
             del headers[hkey]
     return metadata
 
-def retry_url(url, retry_on_404=True):
-    for i in range(0, 10):
+def retry_url(url, retry_on_404=True, num_retries=10):
+    for i in range(0, num_retries):
         try:
             req = urllib2.Request(url)
             resp = urllib2.urlopen(req)
             return resp.read()
         except urllib2.HTTPError, e:
             # in 2.6 you use getcode(), in 2.5 and earlier you use code
             if hasattr(e, 'getcode'):
                 code = e.getcode()
             else:
                 code = e.code
@@ skipping 21 matching lines @@
                     resource = field[0:p] + '/openssh-key'
                 else:
                     key = resource = field
                 val = retry_url(url + resource)
                 p = val.find('\n')
                 if p > 0:
                     val = val.split('\n')
                 d[key] = val
     return d
 
-def get_instance_metadata(version='latest'):
+def get_instance_metadata(version='latest', url='http://169.254.169.254'):
     """
     Returns the instance metadata as a nested Python dictionary.
     Simple values (e.g. local_hostname, hostname, etc.) will be
     stored as string values.  Values such as ancestor-ami-ids will
     be stored in the dict as a list of string values.  More complex
     fields such as public-keys and will be stored as nested dicts.
     """
-    url = 'http://169.254.169.254/%s/meta-data/' % version
-    return _get_instance_metadata(url)
+    return _get_instance_metadata('%s/%s/meta-data/' % (url, version))
 
-def get_instance_userdata(version='latest', sep=None):
-    url = 'http://169.254.169.254/%s/user-data' % version
-    user_data = retry_url(url, retry_on_404=False)
+def get_instance_userdata(version='latest', sep=None,
+                          url='http://169.254.169.254'):
+    ud_url = '%s/%s/user-data' % (url,version)
+    user_data = retry_url(ud_url, retry_on_404=False)
     if user_data:
         if sep:
             l = user_data.split(sep)
             user_data = {}
             for nvpair in l:
                 t = nvpair.split('=')
                 user_data[t[0].strip()] = t[1].strip()
     return user_data
 
 ISO8601 = '%Y-%m-%dT%H:%M:%SZ'
+ISO8601_MS = '%Y-%m-%dT%H:%M:%S.%fZ'
     
 def get_ts(ts=None):
     if not ts:
         ts = time.gmtime()
     return time.strftime(ISO8601, ts)
 
 def parse_ts(ts):
-    return datetime.datetime.strptime(ts, ISO8601)
+    try:
+        dt = datetime.datetime.strptime(ts, ISO8601)
+        return dt
+    except ValueError:
+        dt = datetime.datetime.strptime(ts, ISO8601_MS)
+        return dt
 
 def find_class(module_name, class_name=None):
     if class_name:
         module_name = "%s.%s" % (module_name, class_name)
     modules = module_name.split('.')
     c = None
 
     try:
         for m in modules[1:]:
             if c:
@@ skipping 254 matching lines @@
             item.next.previous = previous
         else:
             self.tail = previous
 
         item.previous = None
         item.next = self.head
         self.head.previous = self.head = item
 
 class Password(object):
     """
-    Password object that stores itself as SHA512 hashed.
+    Password object that stores itself as hashed.
+    Hash defaults to SHA512 if available, MD5 otherwise.
     """
-    def __init__(self, str=None):
+    hashfunc=_hashfn
+    def __init__(self, str=None, hashfunc=None):
         """
-        Load the string from an initial value, this should be the raw SHA512 hashed password
+        Load the string from an initial value, this should be the raw hashed password.
         """
         self.str = str
+        if hashfunc:
+           self.hashfunc = hashfunc
 
     def set(self, value):
-        self.str = _hashfn(value).hexdigest()
+        self.str = self.hashfunc(value).hexdigest()
    
     def __str__(self):
         return str(self.str)
    
     def __eq__(self, other):
         if other == None:
             return False
-        return str(_hashfn(other).hexdigest()) == str(self.str)
+        return str(self.hashfunc(other).hexdigest()) == str(self.str)
 
     def __len__(self):
         if self.str:
             return len(self.str)
         else:
             return 0
 
-def notify(subject, body=None, html_body=None, to_string=None, attachments=[], append_instance_id=True):
+def notify(subject, body=None, html_body=None, to_string=None, attachments=None, append_instance_id=True):
+    attachments = attachments or []
     if append_instance_id:
         subject = "[%s] %s" % (boto.config.get_value("Instance", "instance-id"), subject)
     if not to_string:
         to_string = boto.config.get_value('Notification', 'smtp_to', None)
     if to_string:
         try:
             from_string = boto.config.get_value('Notification', 'smtp_from', 'boto')
             msg = MIMEMultipart()
             msg['From'] = from_string
             msg['Reply-To'] = from_string
@@ skipping 55 matching lines @@
     s = ''
     if name[0].isupper:
         s = name[0].lower()
     for c in name[1:]:
         if c.isupper():
             s += sep + c.lower()
         else:
             s += c
     return s
 
-def awsify_name(name):
-    return name[0:1].upper()+name[1:]
+def write_mime_multipart(content, compress=False, deftype='text/plain', delimiter=':'):
+    """Description:
+    :param content: A list of tuples of name-content pairs. This is used
+    instead of a dict to ensure that scripts run in order
+    :type list of tuples:
+
+    :param compress: Use gzip to compress the scripts, defaults to no compression
+    :type bool:
+
+    :param deftype: The type that should be assumed if nothing else can be figured out
+    :type str:
+
+    :param delimiter: mime delimiter
+    :type str:
+
+    :return: Final mime multipart
+    :rtype: str:
+    """
+    wrapper = MIMEMultipart()
+    for name,con in content:
+        definite_type = guess_mime_type(con, deftype)
+        maintype, subtype = definite_type.split('/', 1)
+        if maintype == 'text':
+            mime_con = MIMEText(con, _subtype=subtype)
+        else:
+            mime_con = MIMEBase(maintype, subtype)
+            mime_con.set_payload(con)
+            # Encode the payload using Base64
+            Encoders.encode_base64(mime_con)
+        mime_con.add_header('Content-Disposition', 'attachment', filename=name)
+        wrapper.attach(mime_con)
+    rcontent = wrapper.as_string()
+
+    if compress:
+        buf = StringIO.StringIO()
+        gz = gzip.GzipFile(mode='wb', fileobj=buf)
+        try:
+            gz.write(rcontent)
+        finally:
+            gz.close()
+        rcontent = buf.getvalue()
+
+    return rcontent
+
+def guess_mime_type(content, deftype):
+    """Description: Guess the mime type of a block of text
+    :param content: content we're finding the type of
+    :type str:
+
+    :param deftype: Default mime type
+    :type str:
+
+    :rtype: <type>:
+    :return: <description>
+    """
+    #Mappings recognized by cloudinit
+    starts_with_mappings={
+        '#include' : 'text/x-include-url',
+        '#!' : 'text/x-shellscript',
+        '#cloud-config' : 'text/cloud-config',
+        '#upstart-job'  : 'text/upstart-job',
+        '#part-handler' : 'text/part-handler',
+        '#cloud-boothook' : 'text/cloud-boothook'
+    }
+    rtype = deftype
+    for possible_type,mimetype in starts_with_mappings.items():
+        if content.startswith(possible_type):
+            rtype = mimetype
+            break
+    return(rtype)