'sh', '-xc',

("i=$interface; x=0; ifconfig down $i || x=$?; "

"ifconfig up $i || x=$?; exit $x")

'/etc/netplan/90-hotplug-azure.yaml',

'/usr/local/sbin/ephemeral_eth.sh',

'/etc/udev/rules.d/10-net-device-added.rules',

'/run/network/interfaces.ephemeral.d',

# extract the 'X' from dev.storvsc.X. if deviceid matches

"""

for line in sysctl_out.splitlines():

if re.search(r"pnpinfo", line):

fields = line.split()

if len(fields) >= 3:

columns = fields[2].split('=')

if (len(columns) >= 2 and

columns[0] == "deviceid" and

columns[1].startswith(deviceid)):

comps = fields[0].split('.')

return comps[2]

# find the scbusX from 'camcontrol devlist -b' output

# if disk_drv matches the specified disk driver, i.e. blkvsc1

"""

for line in camcontrol_out.splitlines():

if re.search(disk_drv, line):

items = line.split()

return items[0]

# find the daX from 'camcontrol devlist' output

# if busdev matches the specified value, i.e. 'scbus2'

"""

for line in camcontrol_out.splitlines():

if re.search(busdev, line):

items = line.split('(')

if len(items) == 2:

dev_pass = items[1].split(',')

return dev_pass[0]

try:

return subp.subp(cmd)[0]

except subp.ProcessExecutionError:

LOG.debug("Failed to execute: %s", ' '.join(cmd))

g0 = "00000000"

if port_id > 1:

g0 = "00000001"

port_id = port_id - 2

g1 = "000" + str(port_id)

g0g1 = "{0}-{1}".format(g0, g1)

# search 'X' from

# 'dev.storvsc.X.%pnpinfo:

# classid=32412632-86cb-44a2-9b5c-50d1417354f5

# deviceid=00000000-0001-8899-0000-000000000000'

sysctl_out = get_dev_storvsc_sysctl()

storvscid = find_storvscid_from_sysctl_pnpinfo(sysctl_out, g0g1)

if not storvscid:

LOG.debug("Fail to find storvsc id from sysctl")

return None

camcontrol_b_out = get_camcontrol_dev_bus()

camcontrol_out = get_camcontrol_dev()

# try to find /dev/XX from 'blkvsc' device

blkvsc = "blkvsc{0}".format(storvscid)

scbusx = find_busdev_from_disk(camcontrol_b_out, blkvsc)

if scbusx:

devname = find_dev_from_busdev(camcontrol_out, scbusx)

if devname is None:

LOG.debug("Fail to find /dev/daX")

return None

return devname

# try to find /dev/XX from 'storvsc' device

storvsc = "storvsc{0}".format(storvscid)

scbusx = find_busdev_from_disk(camcontrol_b_out, storvsc)

if scbusx:

devname = find_dev_from_busdev(camcontrol_out, scbusx)

if devname is None:

LOG.debug("Fail to find /dev/daX")

return None

return devname

'agent_command': AGENT_START_BUILTIN,

'data_dir': AGENT_SEED_DIR,

'set_hostname': True,

'hostname_bounce': {

'interface': DEFAULT_PRIMARY_NIC,

'policy': True,

'command': 'builtin',

'hostname_command': 'hostname',

},

'disk_aliases': {'ephemeral0': RESOURCE_DISK_PATH},

'dhclient_lease_file': LEASE_FILE,

'apply_network_config': True, # Use IMDS published network configuration

'disk_setup': {

'ephemeral0': {'table_type': 'gpt',

'layout': [100],

'overwrite': True},

},

'fs_setup': [{'filesystem': DEFAULT_FS,

'device': 'ephemeral0.1'}],

"""

policy = cfg['hostname_bounce']['policy']

previous_hostname = get_hostname(hostname_command)

if (not util.is_true(cfg.get('set_hostname')) or

util.is_false(policy) or

(previous_hostname == temp_hostname and policy != 'force')):

yield None

return

try:

set_hostname(temp_hostname, hostname_command)

except Exception as e:

report_diagnostic_event(

'Failed setting temporary hostname: %s' % e,

logger_func=LOG.warning)

yield None

return

try:

yield previous_hostname

finally:

dsname = 'Azure'

_negotiated = False

_metadata_imds = sources.UNSET

def __init__(self, sys_cfg, distro, paths):

sources.DataSource.__init__(self, sys_cfg, distro, paths)

self.seed_dir = os.path.join(paths.seed_dir, 'azure')

self.cfg = {}

self.seed = None

self.ds_cfg = util.mergemanydict([

util.get_cfg_by_path(sys_cfg, DS_CFG_PATH, {}),

BUILTIN_DS_CONFIG])

self.dhclient_lease_file = self.ds_cfg.get('dhclient_lease_file')

self._network_config = None

# Regenerate network config new_instance boot and every boot

self.update_events['network'].add(EventType.BOOT)

self._ephemeral_dhcp_ctx = None

self.failed_desired_api_version = False

def __str__(self):

root = sources.DataSource.__str__(self)

return "%s [seed=%s]" % (root, self.seed)

@azure_ds_telemetry_reporter

def bounce_network_with_azure_hostname(self):

# When using cloud-init to provision, we have to set the hostname from

# the metadata and "bounce" the network to force DDNS to update via

# dhclient

azure_hostname = self.metadata.get('local-hostname')

LOG.debug("Hostname in metadata is %s", azure_hostname)

hostname_command = self.ds_cfg['hostname_bounce']['hostname_command']

with temporary_hostname(azure_hostname, self.ds_cfg,

hostname_command=hostname_command) \

as previous_hn:

if (previous_hn is not None and

util.is_true(self.ds_cfg.get('set_hostname'))):

cfg = self.ds_cfg['hostname_bounce']

# "Bouncing" the network

try:

return perform_hostname_bounce(hostname=azure_hostname,

cfg=cfg,

prev_hostname=previous_hn)

except Exception as e:

report_diagnostic_event(

"Failed publishing hostname: %s" % e,

logger_func=LOG.warning)

util.logexc(LOG, "handling set_hostname failed")

return False

def _get_subplatform(self):

"""Return the subplatform metadata source details."""

if self.seed.startswith('/dev'):

subplatform_type = 'config-disk'

else:

subplatform_type = 'seed-dir'

return '%s (%s)' % (subplatform_type, self.seed)

@azure_ds_telemetry_reporter

def crawl_metadata(self):

"""Walk all instance metadata sources returning a dict on success.

crawled_data = {}

# azure removes/ejects the cdrom containing the ovf-env.xml

# file on reboot. So, in order to successfully reboot we

# need to look in the datadir and consider that valid

ddir = self.ds_cfg['data_dir']

# The order in which the candidates are inserted matters here, because

# it determines the value of ret. More specifically, the first one in

# the candidate list determines the path to take in order to get the

# metadata we need.

candidates = [self.seed_dir]

if os.path.isfile(REPROVISION_MARKER_FILE):

candidates.insert(0, "IMDS")

report_diagnostic_event("Reprovision marker file already present "

"before crawling Azure metadata: %s" %

REPROVISION_MARKER_FILE,

logger_func=LOG.debug)

elif os.path.isfile(REPROVISION_NIC_ATTACH_MARKER_FILE):

candidates.insert(0, "NIC_ATTACH_MARKER_PRESENT")

report_diagnostic_event("Reprovision nic attach marker file "

"already present before crawling Azure "

"metadata: %s" %

REPROVISION_NIC_ATTACH_MARKER_FILE,

logger_func=LOG.debug)

candidates.extend(list_possible_azure_ds_devs())

if ddir:

candidates.append(ddir)

found = None

reprovision = False

reprovision_after_nic_attach = False

for cdev in candidates:

try:

if cdev == "IMDS":

ret = None

reprovision = True

elif cdev == "NIC_ATTACH_MARKER_PRESENT":

ret = None

reprovision_after_nic_attach = True

elif cdev.startswith("/dev/"):

if util.is_FreeBSD():

ret = util.mount_cb(cdev, load_azure_ds_dir,

mtype="udf")

else:

ret = util.mount_cb(cdev, load_azure_ds_dir)

else:

ret = load_azure_ds_dir(cdev)

except NonAzureDataSource:

report_diagnostic_event(

"Did not find Azure data source in %s" % cdev,

logger_func=LOG.debug)

continue

except BrokenAzureDataSource as exc:

msg = 'BrokenAzureDataSource: %s' % exc

report_diagnostic_event(msg, logger_func=LOG.error)

raise sources.InvalidMetaDataException(msg)

except util.MountFailedError:

report_diagnostic_event(

'%s was not mountable' % cdev, logger_func=LOG.warning)

continue

perform_reprovision = reprovision or self._should_reprovision(ret)

perform_reprovision_after_nic_attach = (

reprovision_after_nic_attach or

self._should_reprovision_after_nic_attach(ret))

if perform_reprovision or perform_reprovision_after_nic_attach:

if util.is_FreeBSD():

msg = "Free BSD is not supported for PPS VMs"

report_diagnostic_event(msg, logger_func=LOG.error)

raise sources.InvalidMetaDataException(msg)

if perform_reprovision_after_nic_attach:

self._wait_for_all_nics_ready()

ret = self._reprovision()

imds_md = self.get_imds_data_with_api_fallback(

self.fallback_interface,

retries=10

)

(md, userdata_raw, cfg, files) = ret

self.seed = cdev

crawled_data.update({

'cfg': cfg,

'files': files,

'metadata': util.mergemanydict(

[md, {'imds': imds_md}]),

'userdata_raw': userdata_raw})

found = cdev

report_diagnostic_event(

'found datasource in %s' % cdev, logger_func=LOG.debug)

break

if not found:

msg = 'No Azure metadata found'

report_diagnostic_event(msg, logger_func=LOG.error)

raise sources.InvalidMetaDataException(msg)

if found == ddir:

report_diagnostic_event(

"using files cached in %s" % ddir, logger_func=LOG.debug)

seed = _get_random_seed()

if seed:

crawled_data['metadata']['random_seed'] = seed

crawled_data['metadata']['instance-id'] = self._iid()

if perform_reprovision or perform_reprovision_after_nic_attach:

LOG.info("Reporting ready to Azure after getting ReprovisionData")

use_cached_ephemeral = (

self.distro.networking.is_up(self.fallback_interface) and

getattr(self, '_ephemeral_dhcp_ctx', None))

if use_cached_ephemeral:

self._report_ready(lease=self._ephemeral_dhcp_ctx.lease)

self._ephemeral_dhcp_ctx.clean_network() # Teardown ephemeral

else:

try:

with EphemeralDHCPv4WithReporting(

azure_ds_reporter) as lease:

self._report_ready(lease=lease)

except Exception as e:

report_diagnostic_event(

"exception while reporting ready: %s" % e,

logger_func=LOG.error)

raise

return crawled_data

def _is_platform_viable(self):

"""Check platform environment to report if this datasource may run."""

return _is_platform_viable(self.seed_dir)

def clear_cached_attrs(self, attr_defaults=()):

"""Reset any cached class attributes to defaults."""

super(DataSourceAzure, self).clear_cached_attrs(attr_defaults)

self._metadata_imds = sources.UNSET

@azure_ds_telemetry_reporter

def _get_data(self):

"""Crawl and process datasource metadata caching metadata as attrs.

if not self._is_platform_viable():

return False

try:

get_boot_telemetry()

except Exception as e:

LOG.warning("Failed to get boot telemetry: %s", e)

try:

get_system_info()

except Exception as e:

LOG.warning("Failed to get system information: %s", e)

self.distro.networking.blacklist_drivers = BLACKLIST_DRIVERS

try:

crawled_data = util.log_time(

logfunc=LOG.debug, msg='Crawl of metadata service',

func=self.crawl_metadata

)

except Exception as e:

report_diagnostic_event(

'Could not crawl Azure metadata: %s' % e,

logger_func=LOG.error)

self._report_failure(

description=DEFAULT_REPORT_FAILURE_USER_VISIBLE_MESSAGE)

return False

if (self.distro and self.distro.name == 'ubuntu' and

self.ds_cfg.get('apply_network_config')):

maybe_remove_ubuntu_network_config_scripts()

# Process crawled data and augment with various config defaults

# Only merge in default cloud config related to the ephemeral disk

# if the ephemeral disk exists

devpath = RESOURCE_DISK_PATH

if os.path.exists(devpath):

report_diagnostic_event(

"Ephemeral resource disk '%s' exists. "

"Merging default Azure cloud ephemeral disk configs."

% devpath,

logger_func=LOG.debug)

self.cfg = util.mergemanydict(

[crawled_data['cfg'], BUILTIN_CLOUD_EPHEMERAL_DISK_CONFIG])

else:

report_diagnostic_event(

"Ephemeral resource disk '%s' does not exist. "

"Not merging default Azure cloud ephemeral disk configs."

% devpath,

logger_func=LOG.debug)

self.cfg = crawled_data['cfg']

self._metadata_imds = crawled_data['metadata']['imds']

self.metadata = util.mergemanydict(

[crawled_data['metadata'], DEFAULT_METADATA])

self.userdata_raw = crawled_data['userdata_raw']

user_ds_cfg = util.get_cfg_by_path(self.cfg, DS_CFG_PATH, {})

self.ds_cfg = util.mergemanydict([user_ds_cfg, self.ds_cfg])

# walinux agent writes files world readable, but expects

# the directory to be protected.

write_files(

self.ds_cfg['data_dir'], crawled_data['files'], dirmode=0o700)

return True

@azure_ds_telemetry_reporter

def get_imds_data_with_api_fallback(

self,

fallback_nic,

retries,

md_type=metadata_type.compute):

"""

if not self.failed_desired_api_version:

for _ in range(retries):

try:

LOG.info(

"Attempting IMDS api-version: %s",

IMDS_VER_WANT

)

return get_metadata_from_imds(

fallback_nic=fallback_nic,

retries=0,

md_type=md_type,

api_version=IMDS_VER_WANT

)

except UrlError as err:

LOG.info(

"UrlError with IMDS api-version: %s",

IMDS_VER_WANT

)

if err.code == 400:

log_msg = "Fall back to IMDS api-version: {}".format(

IMDS_VER_MIN

)

report_diagnostic_event(

log_msg,

logger_func=LOG.info

)

self.failed_desired_api_version = True

break

LOG.info("Using IMDS api-version: %s", IMDS_VER_MIN)

return get_metadata_from_imds(

fallback_nic=fallback_nic,

retries=retries,

md_type=md_type,

api_version=IMDS_VER_MIN

)

def device_name_to_device(self, name):

return self.ds_cfg['disk_aliases'].get(name)

@azure_ds_telemetry_reporter

def get_public_ssh_keys(self):

"""

LOG.debug('Retrieving public SSH keys')

ssh_keys = []

try:

raise KeyError(

"Not using public SSH keys from IMDS"

)

# pylint:disable=unreachable

ssh_keys = [

public_key['keyData']

for public_key

in self.metadata['imds']['compute']['publicKeys']

]

LOG.debug('Retrieved SSH keys from IMDS')

except KeyError:

log_msg = 'Unable to get keys from IMDS, falling back to OVF'

report_diagnostic_event(log_msg, logger_func=LOG.debug)

try:

ssh_keys = self.metadata['public-keys']

LOG.debug('Retrieved keys from OVF')

except KeyError:

log_msg = 'No keys available from OVF'

report_diagnostic_event(log_msg, logger_func=LOG.debug)

return ssh_keys

def get_config_obj(self):

return self.cfg

def check_instance_id(self, sys_cfg):

# quickly (local check only) if self.instance_id is still valid

return sources.instance_id_matches_system_uuid(self.get_instance_id())

def _iid(self, previous=None):

prev_iid_path = os.path.join(

self.paths.get_cpath('data'), 'instance-id')

# Older kernels than 4.15 will have UPPERCASE product_uuid.

# We don't want Azure to react to an UPPER/lower difference as a new

# instance id as it rewrites SSH host keys.

# LP: #1835584

iid = dmi.read_dmi_data('system-uuid').lower()

if os.path.exists(prev_iid_path):

previous = util.load_file(prev_iid_path).strip()

if previous.lower() == iid:

# If uppercase/lowercase equivalent, return the previous value

# to avoid new instance id.

return previous

if is_byte_swapped(previous.lower(), iid):

return previous

return iid

@azure_ds_telemetry_reporter

def setup(self, is_new_instance):

if self._negotiated is False:

LOG.debug("negotiating for %s (new_instance=%s)",

self.get_instance_id(), is_new_instance)

fabric_data = self._negotiate()

LOG.debug("negotiating returned %s", fabric_data)

if fabric_data:

self.metadata.update(fabric_data)

self._negotiated = True

else:

LOG.debug("negotiating already done for %s",

self.get_instance_id())

@azure_ds_telemetry_reporter

def _wait_for_nic_detach(self, nl_sock):

"""Use the netlink socket provided to wait for nic detach event.

try:

ifname = None

# Preprovisioned VM will only have one NIC, and it gets

# detached immediately after deployment.

with events.ReportEventStack(

name="wait-for-nic-detach",

description=("wait for nic detach"),

parent=azure_ds_reporter):

ifname = netlink.wait_for_nic_detach_event(nl_sock)

if ifname is None:

msg = ("Preprovisioned nic not detached as expected. "

"Proceeding without failing.")

report_diagnostic_event(msg, logger_func=LOG.warning)

else:

report_diagnostic_event("The preprovisioned nic %s is detached"

% ifname, logger_func=LOG.warning)

path = REPROVISION_NIC_DETACHED_MARKER_FILE

LOG.info("Creating a marker file for nic detached: %s", path)

util.write_file(path, "{pid}: {time}\n".format(

pid=os.getpid(), time=time()))

except AssertionError as error:

report_diagnostic_event(error, logger_func=LOG.error)

raise

@azure_ds_telemetry_reporter

def wait_for_link_up(self, ifname):

"""In cases where the link state is still showing down after a nic is

if self.distro.networking.try_set_link_up(ifname):

report_diagnostic_event("The link %s is already up." % ifname,

logger_func=LOG.info)

return

LOG.info("Attempting to bring %s up", ifname)

attempts = 0

while True:

LOG.info("Unbinding and binding the interface %s", ifname)

devicename = net.read_sys_net(ifname,

'device/device_id').strip('{}')

util.write_file('/sys/bus/vmbus/drivers/hv_netvsc/unbind',

devicename)

util.write_file('/sys/bus/vmbus/drivers/hv_netvsc/bind',

devicename)

attempts = attempts + 1

if self.distro.networking.try_set_link_up(ifname):

msg = "The link %s is up after %s attempts" % (ifname,

attempts)

report_diagnostic_event(msg, logger_func=LOG.info)

return

sleep_duration = 1

msg = ("Link is not up after %d attempts with %d seconds sleep "

"between attempts." % (attempts, sleep_duration))

if attempts % 10 == 0:

report_diagnostic_event(msg, logger_func=LOG.info)

else:

LOG.info(msg)

sleep(sleep_duration)

@azure_ds_telemetry_reporter

def _create_report_ready_marker(self):

path = REPORTED_READY_MARKER_FILE

LOG.info(

"Creating a marker file to report ready: %s", path)

util.write_file(path, "{pid}: {time}\n".format(

pid=os.getpid(), time=time()))

report_diagnostic_event(

'Successfully created reported ready marker file '

'while in the preprovisioning pool.',

logger_func=LOG.debug)

@azure_ds_telemetry_reporter

def _report_ready_if_needed(self):

"""Report ready to the platform if the marker file is not present,

have_not_reported_ready = (

not os.path.isfile(REPORTED_READY_MARKER_FILE))

if have_not_reported_ready:

report_diagnostic_event("Reporting ready before nic detach",

logger_func=LOG.info)

try:

with EphemeralDHCPv4WithReporting(azure_ds_reporter) as lease:

self._report_ready(lease=lease)

except Exception as e:

report_diagnostic_event("Exception reporting ready during "

"preprovisioning before nic detach: %s"

% e, logger_func=LOG.error)

raise

self._create_report_ready_marker()

else:

report_diagnostic_event("Already reported ready before nic detach."

" The marker file already exists: %s" %

REPORTED_READY_MARKER_FILE,

logger_func=LOG.error)

@azure_ds_telemetry_reporter

def _check_if_nic_is_primary(self, ifname):

"""Check if a given interface is the primary nic or not. If it is the

is_primary = False

expected_nic_count = -1

imds_md = None

# For now, only a VM's primary NIC can contact IMDS and WireServer. If

# DHCP fails for a NIC, we have no mechanism to determine if the NIC is

# primary or secondary. In this case, the desired behavior is to fail

# VM provisioning if there is any DHCP failure when trying to determine

# the primary NIC.

try:

with events.ReportEventStack(

name="obtain-dhcp-lease",

description=("obtain dhcp lease for %s when attempting to "

"determine primary NIC during reprovision of "

"a pre-provisioned VM" % ifname),

parent=azure_ds_reporter):

dhcp_ctx = EphemeralDHCPv4(

iface=ifname,

dhcp_log_func=dhcp_log_cb)

dhcp_ctx.obtain_lease()

except Exception as e:

report_diagnostic_event("Giving up. Failed to obtain dhcp lease "

"for %s when attempting to determine "

"primary NIC during reprovision due to %s"

% (ifname, e), logger_func=LOG.error)

raise

# Primary nic detection will be optimized in the future. The fact that

# primary nic is being attached first helps here. Otherwise each nic

# could add several seconds of delay.

try:

imds_md = self.get_imds_data_with_api_fallback(

ifname,

5,

metadata_type.network

)

except Exception as e:

LOG.warning(

"Failed to get network metadata using nic %s. Attempt to "

"contact IMDS failed with error %s. Assuming this is not the "

"primary nic.", ifname, e)

finally:

# If we are not the primary nic, then clean the dhcp context.

if imds_md is None:

dhcp_ctx.clean_network()

if imds_md is not None:

# Only primary NIC will get a response from IMDS.

LOG.info("%s is the primary nic", ifname)

is_primary = True

# If primary, set ephemeral dhcp ctx so we can report ready

self._ephemeral_dhcp_ctx = dhcp_ctx

# Set the expected nic count based on the response received.

expected_nic_count = len(

imds_md['interface'])

report_diagnostic_event("Expected nic count: %d" %

expected_nic_count, logger_func=LOG.info)

return is_primary, expected_nic_count

@azure_ds_telemetry_reporter

def _wait_for_hot_attached_nics(self, nl_sock):

"""Wait until all the expected nics for the vm are hot-attached.

LOG.info("Waiting for nics to be hot-attached")

try:

# Wait for nics to be attached one at a time, until we know for

# sure that all nics have been attached.

nics_found = []

primary_nic_found = False

expected_nic_count = -1

# Wait for netlink nic attach events. After the first nic is

# attached, we are already in the customer vm deployment path and

# so eerything from then on should happen fast and avoid

# unnecessary delays wherever possible.

while True:

ifname = None

with events.ReportEventStack(

name="wait-for-nic-attach",

description=("wait for nic attach after %d nics have "

"been attached" % len(nics_found)),

parent=azure_ds_reporter):

ifname = netlink.wait_for_nic_attach_event(nl_sock,

nics_found)

# wait_for_nic_attach_event guarantees that ifname it not None

nics_found.append(ifname)

report_diagnostic_event("Detected nic %s attached." % ifname,

logger_func=LOG.info)

# Attempt to bring the interface's operating state to

# UP in case it is not already.

self.wait_for_link_up(ifname)

# If primary nic is not found, check if this is it. The

# platform will attach the primary nic first so we

# won't be in primary_nic_found = false state for long.

if not primary_nic_found:

LOG.info("Checking if %s is the primary nic",

ifname)

(primary_nic_found, expected_nic_count) = (

self._check_if_nic_is_primary(ifname))

# Exit criteria: check if we've discovered all nics

if (expected_nic_count != -1

and len(nics_found) >= expected_nic_count):

LOG.info("Found all the nics for this VM.")

break

except AssertionError as error:

report_diagnostic_event(error, logger_func=LOG.error)

@azure_ds_telemetry_reporter

def _wait_for_all_nics_ready(self):

"""Wait for nic(s) to be hot-attached. There may be multiple nics

nl_sock = None

try:

nl_sock = netlink.create_bound_netlink_socket()

report_ready_marker_present = bool(

os.path.isfile(REPORTED_READY_MARKER_FILE))

# Report ready if the marker file is not already present.

# The nic of the preprovisioned vm gets hot-detached as soon as

# we report ready. So no need to save the dhcp context.

self._report_ready_if_needed()

has_nic_been_detached = bool(

os.path.isfile(REPROVISION_NIC_DETACHED_MARKER_FILE))

if not has_nic_been_detached:

LOG.info("NIC has not been detached yet.")

self._wait_for_nic_detach(nl_sock)