'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'

default_update_events = {EventScope.NETWORK: {

EventType.BOOT_NEW_INSTANCE,

EventType.BOOT,

}}

_negotiated = False

_metadata_imds = sources.UNSET

_ci_pkl_version = 1

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

self._ephemeral_dhcp_ctx = None

self.failed_desired_api_version = False

self.iso_dev = None

def _unpickle(self, ci_pkl_version: int) -> None:

super()._unpickle(ci_pkl_version)

if not hasattr(self, "failed_desired_api_version"):

self.failed_desired_api_version = False

if not hasattr(self, "iso_dev"):

self.iso_dev = None

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'

elif self.seed.lower() == 'imds':

subplatform_type = 'imds'

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.

reprovision = False

ovf_is_accessible = True

reprovision_after_nic_attach = False

metadata_source = None

ret = None

if os.path.isfile(REPROVISION_MARKER_FILE):

reprovision = True

metadata_source = "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):

reprovision_after_nic_attach = True

metadata_source = "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)

else:

for src in list_possible_azure_ds(self.seed_dir, ddir):

try:

if src.startswith("/dev/"):

if util.is_FreeBSD():

ret = util.mount_cb(src, load_azure_ds_dir,

mtype="udf")

else:

ret = util.mount_cb(src, load_azure_ds_dir)

# save the device for ejection later

self.iso_dev = src

ovf_is_accessible = True

else:

ret = load_azure_ds_dir(src)

metadata_source = src

break

except NonAzureDataSource:

report_diagnostic_event(

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

logger_func=LOG.debug)

continue

except util.MountFailedError:

report_diagnostic_event(

'%s was not mountable' % src,

logger_func=LOG.debug)

ovf_is_accessible = False

empty_md = {'local-hostname': ''}

empty_cfg = dict(

system_info=dict(

default_user=dict(

name=''

)

)

)

ret = (empty_md, '', empty_cfg, {})

metadata_source = 'IMDS'

continue

except BrokenAzureDataSource as exc:

msg = 'BrokenAzureDataSource: %s' % exc

report_diagnostic_event(msg, logger_func=LOG.error)

raise sources.InvalidMetaDataException(msg)

report_diagnostic_event(

"Found provisioning metadata in %s" % metadata_source,

logger_func=LOG.debug)

imds_md = self.get_imds_data_with_api_fallback(

self.fallback_interface,

retries=10

)

# reset _fallback_interface so that if the code enters reprovisioning

# flow, it will force re-evaluation of new fallback nic.

self._fallback_interface = None

if not imds_md and not ovf_is_accessible:

msg = 'No OVF or IMDS available'

report_diagnostic_event(msg)

raise sources.InvalidMetaDataException(msg)

perform_reprovision = (

reprovision or

self._should_reprovision(ret, imds_md))

perform_reprovision_after_nic_attach = (

reprovision_after_nic_attach or

self._should_reprovision_after_nic_attach(ret, imds_md))

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()

# fetch metadata again as it has changed after reprovisioning

imds_md = self.get_imds_data_with_api_fallback(

self.fallback_interface,

retries=10

)

(md, userdata_raw, cfg, files) = ret

self.seed = metadata_source

crawled_data.update({

'cfg': cfg,

'files': files,

'metadata': util.mergemanydict(

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

'userdata_raw': userdata_raw})

imds_username = _username_from_imds(imds_md)

imds_hostname = _hostname_from_imds(imds_md)

imds_disable_password = _disable_password_from_imds(imds_md)

if imds_username:

LOG.debug('Username retrieved from IMDS: %s', imds_username)

cfg['system_info']['default_user']['name'] = imds_username

if imds_hostname:

LOG.debug('Hostname retrieved from IMDS: %s', imds_hostname)

crawled_data['metadata']['local-hostname'] = imds_hostname

if imds_disable_password:

LOG.debug(

'Disable password retrieved from IMDS: %s',

imds_disable_password

)

crawled_data['metadata']['disable_password'] = imds_disable_password # noqa: E501

if metadata_source == 'IMDS' and not crawled_data['files']:

try:

contents = build_minimal_ovf(

username=imds_username,

hostname=imds_hostname,

disableSshPwd=imds_disable_password)

crawled_data['files'] = {'ovf-env.xml': contents}

except Exception as e:

report_diagnostic_event(

"Failed to construct OVF from IMDS data %s" % e,

logger_func=LOG.debug)

# only use userdata from imds if OVF did not provide custom data

# userdata provided by IMDS is always base64 encoded

if not userdata_raw:

imds_userdata = _userdata_from_imds(imds_md)

if imds_userdata:

LOG.debug("Retrieved userdata from IMDS")

try:

crawled_data['userdata_raw'] = base64.b64decode(

''.join(imds_userdata.split()))

except Exception:

report_diagnostic_event(

"Bad userdata in IMDS",

logger_func=LOG.warning)

if not metadata_source:

msg = 'No Azure metadata found'

report_diagnostic_event(msg, logger_func=LOG.error)

raise sources.InvalidMetaDataException(msg)

else:

report_diagnostic_event(

'found datasource in %s' % metadata_source,

logger_func=LOG.debug)

if metadata_source == 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.all,

exc_cb=retry_on_url_exc,

infinite=False):

"""

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,

exc_cb=exc_cb

)

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,

exc_cb=exc_cb,

infinite=infinite

)

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):

"""

return self._get_public_ssh_keys_and_source().ssh_keys

def _get_public_ssh_keys_and_source(self):

"""

LOG.debug('Retrieving public SSH keys')

ssh_keys = []

keys_from_imds = True

LOG.debug('Attempting to get SSH keys from IMDS')

try:

ssh_keys = [

public_key['keyData']

for public_key

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

]

for key in ssh_keys:

if not _key_is_openssh_formatted(key=key):

keys_from_imds = False

break

if not keys_from_imds:

log_msg = 'Keys not in OpenSSH format, using OVF'

else:

log_msg = 'Retrieved {} keys from IMDS'.format(

len(ssh_keys)

if ssh_keys is not None

else 0

)

except KeyError:

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

keys_from_imds = False

finally:

report_diagnostic_event(log_msg, logger_func=LOG.debug)

if not keys_from_imds:

LOG.debug('Attempting to get SSH keys from OVF')

try:

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

log_msg = 'Retrieved {} keys from OVF'.format(len(ssh_keys))

except KeyError:

log_msg = 'No keys available from OVF'

finally:

report_diagnostic_event(log_msg, logger_func=LOG.debug)

return SSHKeys(

keys_from_imds=keys_from_imds,

ssh_keys=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.debug("Attempting to bring %s up", ifname)

attempts = 0

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

while True:

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

if attempts % 10 == 0:

msg = ("Link is not up after %d attempts to rebind" % attempts)

report_diagnostic_event(msg, logger_func=LOG.info)

LOG.info(msg)

# It could take some time after rebind for the interface to be up.

# So poll for the status for some time before attempting to rebind

# again.

sleep_duration = 0.5

max_status_polls = 20

LOG.debug("Polling %d seconds for primary NIC link up after "

"rebind.", sleep_duration * max_status_polls)

for i in range(0, max_status_polls):

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

msg = ("After %d attempts to rebind, link is up after "

"polling the link status %d times" % (attempts, i))

report_diagnostic_event(msg, logger_func=LOG.info)

LOG.debug(msg)

return

else:

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

metadata_poll_count = 0

metadata_logging_threshold = 1

expected_errors_count = 0