← Back to branch summary

~ubuntu-branches/ubuntu/lucid/cloud-init/lucid-updates

« back to all changes in this revision

Viewing changes to cloudinit/DataSourceEc2.py

  • Committer: Bazaar Package Importer
  • Author(s): Scott Moser
  • Date: 2010-02-04 03:00:05 UTC
  • Revision ID: james.westby@ubuntu.com-20100204030005-r2y1568be8rbslxo
Tags: upstream-0.5.3
Import upstream version 0.5.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
cloudinit/DataSourceEc2.py
 
1
import DataSource
 
2
 
 
3
import cloudinit
 
4
import socket
 
5
import urllib2
 
6
import time
 
7
import boto_utils
 
8
 
 
9
class DataSourceEc2(DataSource.DataSource):
 
10
    api_ver  = '2009-04-04'
 
11
    cachedir = cloudinit.cachedir + '/ec2'
 
12
 
 
13
    location_locale_map = { 
 
14
        'us' : 'en_US.UTF-8',
 
15
        'eu' : 'en_GB.UTF-8',
 
16
        'default' : 'en_US.UTF-8',
 
17
    }
 
18
 
 
19
    def __init__(self):
 
20
        pass
 
21
 
 
22
    def get_data(self):
 
23
        try:
 
24
            udf = open(self.cachedir + "/user-data.raw")
 
25
            self.userdata_raw = udf.read()
 
26
            udf.close()
 
27
 
 
28
            mdf = open(self.cachedir + "/meta-data.raw")
 
29
            data = mdf.read()
 
30
            self.metadata = eval(data)
 
31
            mdf.close()
 
32
 
 
33
            return True
 
34
        except:
 
35
            pass
 
36
 
 
37
        try:
 
38
            if not self.wait_for_metadata_service():
 
39
                return False
 
40
            self.userdata_raw = boto_utils.get_instance_userdata(self.api_ver)
 
41
            self.metadata = boto_utils.get_instance_metadata(self.api_ver)
 
42
            return True
 
43
        except Exception as e:
 
44
            print e
 
45
            return False
 
46
 
 
47
    def get_instance_id(self):
 
48
        return(self.metadata['instance-id'])
 
49
 
 
50
    def get_availability_zone(self):
 
51
        return(self.metadata['placement']['availability-zone'])
 
52
 
 
53
    def get_local_mirror(self):
 
54
        return(self.get_mirror_from_availability_zone())
 
55
 
 
56
    def get_locale(self):
 
57
        az = self.metadata['placement']['availability-zone']
 
58
        if self.location_locale_map.has_key(az[0:2]):
 
59
            return(self.location_locale_map[az[0:2]])
 
60
        else:
 
61
            return(self.location_locale_map["default"])
 
62
 
 
63
    def get_hostname(self):
 
64
        toks = self.metadata['local-hostname'].split('.')
 
65
        # if there is an ipv4 address in 'local-hostname', then
 
66
        # make up a hostname (LP: #475354)
 
67
        if len(toks) == 4:
 
68
            try:
 
69
                r = filter(lambda x: int(x) < 256 and x > 0, toks)
 
70
                if len(r) == 4:
 
71
                    return("ip-%s" % '-'.join(r))
 
72
            except: pass
 
73
        return toks[0]
 
74
 
 
75
    def get_mirror_from_availability_zone(self, availability_zone = None):
 
76
        # availability is like 'us-west-1b' or 'eu-west-1a'
 
77
        if availability_zone == None:
 
78
            availability_zone = self.get_availability_zone()
 
79
 
 
80
        try:
 
81
            host="%s.ec2.archive.ubuntu.com" % availability_zone[:-1]
 
82
            socket.getaddrinfo(host, None, 0, socket.SOCK_STREAM)
 
83
            return 'http://%s/ubuntu/' % host
 
84
        except:
 
85
            return 'http://archive.ubuntu.com/ubuntu/'
 
86
 
 
87
    def wait_for_metadata_service(self, sleeps = 10):
 
88
        sleeptime = 1
 
89
        for x in range(sleeps):
 
90
            s = socket.socket()
 
91
            try:
 
92
                address = '169.254.169.254'
 
93
                port = 80
 
94
                s.connect((address,port))
 
95
                s.close()
 
96
                return True
 
97
            except socket.error, e:
 
98
                print "sleeping %s" % sleeptime
 
99
                time.sleep(sleeptime)
 
100
                #timeout = timeout * 2
 
101
        return False
 
102
 
 
103
    def get_public_ssh_keys(self):
 
104
        keys = []
 
105
        if not self.metadata.has_key('public-keys'): return([])
 
106
        for keyname, klist in self.metadata['public-keys'].items():
 
107
            # lp:506332 uec metadata service responds with
 
108
            # data that makes boto populate a string for 'klist' rather
 
109
            # than a list.
 
110
            if isinstance(klist,str):
 
111
                klist = [ klist ]
 
112
            for pkey in klist:
 
113
                # there is an empty string at the end of the keylist, trim it
 
114
                if pkey:
 
115
                    keys.append(pkey)
 
116
 
 
117
        return(keys)
 
118
 
 
119
    def device_name_to_device(self, name):
 
120
        # consult metadata service, that has
 
121
        #  ephemeral0: sdb
 
122
        # and return 'sdb' for input 'ephemeral0'
 
123
        if not self.metadata.has_key('block-device-mapping'):
 
124
            return(None)
 
125
 
 
126
        for entname, device in self.metadata['block-device-mapping'].items():
 
127
            if entname == name:
 
128
                return(device)
 
129
            # LP: #513842 mapping in Euca has 'ephemeral' not 'ephemeral0'
 
130
            if entname == "ephemeral" and name == "ephemeral0":
 
131
                return(device)
 
132
        return None