240 lines
8.1 KiB
Python
240 lines
8.1 KiB
Python
# vi: ts=4 expandtab
|
|
#
|
|
# Copyright (C) 2009-2010 Canonical Ltd.
|
|
#
|
|
# Author: Scott Moser <scott.moser@canonical.com>
|
|
#
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License version 3, as
|
|
# published by the Free Software Foundation.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
import DataSource
|
|
|
|
from cloudinit import seeddir, log
|
|
import cloudinit.util as util
|
|
import socket
|
|
import urllib2
|
|
import time
|
|
import sys
|
|
import boto.utils as boto_utils
|
|
import os.path
|
|
import errno
|
|
import urlparse
|
|
|
|
class DataSourceEc2(DataSource.DataSource):
|
|
api_ver = '2009-04-04'
|
|
seeddir = seeddir + '/ec2'
|
|
metadata_address = "http://169.254.169.254"
|
|
|
|
def __str__(self):
|
|
return("DataSourceEc2")
|
|
|
|
def get_data(self):
|
|
seedret={ }
|
|
if util.read_optional_seed(seedret,base=self.seeddir+ "/"):
|
|
self.userdata_raw = seedret['user-data']
|
|
self.metadata = seedret['meta-data']
|
|
log.debug("using seeded ec2 data in %s" % self.seeddir)
|
|
return True
|
|
|
|
try:
|
|
if not self.wait_for_metadata_service():
|
|
return False
|
|
self.userdata_raw = boto_utils.get_instance_userdata(self.api_ver, None, self.metadata_address)
|
|
self.metadata = boto_utils.get_instance_metadata(self.api_ver, self.metadata_address)
|
|
return True
|
|
except Exception as e:
|
|
print e
|
|
return False
|
|
|
|
def get_instance_id(self):
|
|
return(self.metadata['instance-id'])
|
|
|
|
def get_availability_zone(self):
|
|
return(self.metadata['placement']['availability-zone'])
|
|
|
|
def get_local_mirror(self):
|
|
return(self.get_mirror_from_availability_zone())
|
|
|
|
def get_mirror_from_availability_zone(self, availability_zone = None):
|
|
# availability is like 'us-west-1b' or 'eu-west-1a'
|
|
if availability_zone == None:
|
|
availability_zone = self.get_availability_zone()
|
|
|
|
fallback = None
|
|
|
|
if self.is_vpc():
|
|
return fallback
|
|
|
|
try:
|
|
host="%s.ec2.archive.ubuntu.com" % availability_zone[:-1]
|
|
socket.getaddrinfo(host, None, 0, socket.SOCK_STREAM)
|
|
return 'http://%s/ubuntu/' % host
|
|
except:
|
|
return fallback
|
|
|
|
|
|
def wait_for_metadata_service(self, sleeps = None):
|
|
mcfg = self.ds_cfg
|
|
if sleeps is None:
|
|
sleeps = 30
|
|
try:
|
|
sleeps = int(mcfg.get("retries",sleeps))
|
|
except Exception as e:
|
|
util.logexc(log)
|
|
log.warn("Failed to get number of sleeps, using %s" % sleeps)
|
|
|
|
if sleeps == 0: return False
|
|
|
|
timeout=3
|
|
try:
|
|
timeout = int(mcfg.get("timeout",timeout))
|
|
except Exception as e:
|
|
util.logexc(log)
|
|
log.warn("Failed to get timeout, using %s" % timeout)
|
|
|
|
sleeptime = 1
|
|
|
|
def_mdurls = ["http://169.254.169.254", "http://instance-data:8773"]
|
|
try:
|
|
mdurls = mcfg.get("metadata_urls", def_mdurls)
|
|
except Exception as e:
|
|
mdurls = def_mdurls
|
|
util.logexc(log)
|
|
log.warn("Failed to get metadata URLs, using defaults")
|
|
|
|
starttime = time.time()
|
|
|
|
# Remove addresses from the list that wont resolve.
|
|
filtered = [x for x in mdurls if try_to_resolve_metadata(x)]
|
|
|
|
if set(filtered) != set(mdurls):
|
|
log.debug("removed the following from metadata urls: %s" %
|
|
list((set(mdurls) - set(filtered))))
|
|
|
|
if len(filtered):
|
|
mdurls = filtered
|
|
else:
|
|
log.warn("Empty metadata url list! using default list")
|
|
mdurls = def_mdurls
|
|
|
|
log.debug("Searching the following metadata urls: %s" % mdurls)
|
|
|
|
for x in range(sleeps):
|
|
for url in mdurls:
|
|
iurl="%s/%s/meta-data/instance-id" % (url, self.api_ver)
|
|
|
|
# given 100 sleeps, this ends up total sleep time of 1050 sec
|
|
sleeptime=int(x/5)+1
|
|
|
|
reason = ""
|
|
try:
|
|
req = urllib2.Request(iurl)
|
|
resp = urllib2.urlopen(req, timeout=timeout)
|
|
if resp.read() != "":
|
|
self.metadata_address = url
|
|
log.debug("Using metadata source: '%s'" % url)
|
|
return True
|
|
reason = "empty data [%s]" % resp.getcode()
|
|
except urllib2.HTTPError as e:
|
|
reason = "http error [%s]" % e.code
|
|
except urllib2.URLError as e:
|
|
reason = "url error [%s]" % e.reason
|
|
except socket.timeout as e:
|
|
reason = "socket timeout [%s]" % e
|
|
|
|
#not needed? Addresses being checked are displayed above
|
|
#if x == 0:
|
|
# log.warn("waiting for metadata service at %s" % url)
|
|
|
|
log.warn("'%s' failed: %s" % (url, reason))
|
|
time.sleep(sleeptime)
|
|
|
|
log.critical("giving up on md after %i seconds\n" %
|
|
int(time.time()-starttime))
|
|
return False
|
|
|
|
def device_name_to_device(self, name):
|
|
# consult metadata service, that has
|
|
# ephemeral0: sdb
|
|
# and return 'sdb' for input 'ephemeral0'
|
|
if not self.metadata.has_key('block-device-mapping'):
|
|
return(None)
|
|
|
|
found = None
|
|
for entname, device in self.metadata['block-device-mapping'].items():
|
|
if entname == name:
|
|
found = device
|
|
break
|
|
# LP: #513842 mapping in Euca has 'ephemeral' not 'ephemeral0'
|
|
if entname == "ephemeral" and name == "ephemeral0":
|
|
found = device
|
|
if found == None:
|
|
log.debug("unable to convert %s to a device" % name)
|
|
return None
|
|
|
|
# LP: #611137
|
|
# the metadata service may believe that devices are named 'sda'
|
|
# when the kernel named them 'vda' or 'xvda'
|
|
# we want to return the correct value for what will actually
|
|
# exist in this instance
|
|
mappings = { "sd": ("vd", "xvd") }
|
|
ofound = found
|
|
short = os.path.basename(found)
|
|
|
|
if not found.startswith("/"):
|
|
found="/dev/%s" % found
|
|
|
|
if os.path.exists(found):
|
|
return(found)
|
|
|
|
for nfrom, tlist in mappings.items():
|
|
if not short.startswith(nfrom): continue
|
|
for nto in tlist:
|
|
cand = "/dev/%s%s" % (nto, short[len(nfrom):])
|
|
if os.path.exists(cand):
|
|
log.debug("remapped device name %s => %s" % (found,cand))
|
|
return(cand)
|
|
|
|
# on t1.micro, ephemeral0 will appear in block-device-mapping from
|
|
# metadata, but it will not exist on disk (and never will)
|
|
# at this pint, we've verified that the path did not exist
|
|
# in the special case of 'ephemeral0' return None to avoid bogus
|
|
# fstab entry (LP: #744019)
|
|
if name == "ephemeral0":
|
|
return None
|
|
return ofound
|
|
|
|
def is_vpc(self):
|
|
# per comment in LP: #615545
|
|
ph="public-hostname"; p4="public-ipv4"
|
|
if ((ph not in self.metadata or self.metadata[ph] == "") and
|
|
(p4 not in self.metadata or self.metadata[p4] == "")):
|
|
return True
|
|
return False
|
|
|
|
def try_to_resolve_metadata(url):
|
|
try:
|
|
addr = urlparse.urlsplit(url).netloc.split(":")[0]
|
|
socket.getaddrinfo(addr, None)
|
|
return True
|
|
except Exception as e:
|
|
return False
|
|
|
|
|
|
datasources = [
|
|
( DataSourceEc2, ( DataSource.DEP_FILESYSTEM , DataSource.DEP_NETWORK ) ),
|
|
]
|
|
|
|
# return a list of data sources that match this set of dependencies
|
|
def get_datasource_list(depends):
|
|
return(DataSource.list_from_depends(depends, datasources))
|