def copy_ovf_env(self):
"""
Copy ovf env file from dvd to hard disk.
Remove password before save it to the disk
"""
dvd_mount_point = conf.get_dvd_mount_point()
ovf_file_path_on_dvd = os.path.join(dvd_mount_point, OVF_FILE_NAME)
tag_file_path_on_dvd = os.path.join(dvd_mount_point, TAG_FILE_NAME)
try:
self.distro.osutil.mount_dvd()
ovfxml = fileutil.read_file(ovf_file_path_on_dvd, remove_bom=True)
ovfenv = OvfEnv(ovfxml)
ovfxml = re.sub("<UserPassword>.*?<", "<UserPassword>*<", ovfxml)
ovf_file_path = os.path.join(conf.get_lib_dir(), OVF_FILE_NAME)
fileutil.write_file(ovf_file_path, ovfxml)
if os.path.isfile(tag_file_path_on_dvd):
logger.info("Found {0} in provisioning ISO", TAG_FILE_NAME)
tag_file_path = os.path.join(conf.get_lib_dir(), TAG_FILE_NAME)
shutil.copyfile(tag_file_path_on_dvd, tag_file_path)
except (OSUtilError, IOError) as e:
raise ProtocolError(ustr(e))
try:
self.distro.osutil.umount_dvd()
self.distro.osutil.eject_dvd()
except OSUtilError as e:
logger.warn(ustr(e))
return ovfenv
def collect_and_send_events(self):
event_list = TelemetryEventList()
event_dir = os.path.join(conf.get_lib_dir(), "events")
event_files = os.listdir(event_dir)
for event_file in event_files:
if not event_file.endswith(".tld"):
continue
event_file_path = os.path.join(event_dir, event_file)
try:
data_str = self.collect_event(event_file_path)
except EventError as e:
logger.error("{0}", e)
continue
try:
event = parse_event(data_str)
event.parameters.extend(self.sysinfo)
event_list.events.append(event)
except (ValueError, ProtocolError) as e:
logger.warn("Failed to decode event file: {0}", e)
continue
if len(event_list.events) == 0:
return
try:
protocol = self.distro.protocol_util.get_protocol()
protocol.report_event(event_list)
except ProtocolError as e:
logger.error("{0}", e)
def mount_resource_disk(self, mount_point, fs):
device = self.distro.osutil.device_for_ide_port(1)
if device is None:
raise ResourceDiskError("unable to detect disk topology")
device = "/dev/" + device
mountlist = shellutil.run_get_output("mount")[1]
existing = self.distro.osutil.get_mount_point(mountlist, device)
if(existing):
logger.info("Resource disk {0}1 is already mounted", device)
return existing
fileutil.mkdir(mount_point, mode=0o755)
logger.info("Detect GPT...")
partition = device + "1"
ret = shellutil.run_get_output("parted {0} print".format(device))
if ret[0]:
raise ResourceDiskError("({0}) {1}".format(device, ret[1]))
if "gpt" in ret[1]:
logger.info("GPT detected")
logger.info("Get GPT partitions")
parts = [x for x in ret[1].split("\n") if re.match("^\s*[0-9]+", x)]
logger.info("Found more than {0} GPT partitions.", len(parts))
if len(parts) > 1:
logger.info("Remove old GPT partitions")
for i in range(1, len(parts) + 1):
logger.info("Remove partition: {0}", i)
shellutil.run("parted {0} rm {1}".format(device, i))
logger.info("Create a new GPT partition using entire disk space")
shellutil.run("parted {0} mkpart primary 0% 100%".format(device))
logger.info("Format partition: {0} with fstype {1}",partition,fs)
shellutil.run("mkfs." + fs + " " + partition + " -F")
else:
logger.info("GPT not detected")
logger.info("Check fstype")
ret = shellutil.run_get_output("sfdisk -q -c {0} 1".format(device))
if ret[1].rstrip() == "7" and fs != "ntfs":
logger.info("The partition is formatted with ntfs")
logger.info("Format partition: {0} with fstype {1}",partition,fs)
shellutil.run("sfdisk -c {0} 1 83".format(device))
shellutil.run("mkfs." + fs + " " + partition + " -F")
logger.info("Mount resource disk")
ret = shellutil.run("mount {0} {1}".format(partition, mount_point),
chk_err=False)
if ret:
logger.warn("Failed to mount resource disk. Retry mounting")
shellutil.run("mkfs." + fs + " " + partition + " -F")
ret = shellutil.run("mount {0} {1}".format(partition, mount_point))
if ret:
raise ResourceDiskError("({0}) {1}".format(partition, ret))
logger.info("Resource disk ({0}) is mounted at {1} with fstype {2}",
device, mount_point, fs)
return mount_point
def get_distro(distro_name=DISTRO_NAME, distro_version=DISTRO_VERSION,
distro_full_name=DISTRO_FULL_NAME):
if distro_name == "ubuntu":
if Version(distro_version) == Version("12.04") or \
Version(distro_version) == Version("12.10"):
return Ubuntu12Distro()
elif Version(distro_version) == Version("14.04") or \
Version(distro_version) == Version("14.10"):
return Ubuntu14Distro()
elif distro_full_name == "Snappy Ubuntu Core":
return UbuntuSnappyDistro()
else:
return UbuntuDistro()
if distro_name == "coreos":
return CoreOSDistro()
if distro_name == "suse":
if distro_full_name=='SUSE Linux Enterprise Server' and \
Version(distro_version) < Version('12') or \
distro_full_name == 'openSUSE' and \
Version(distro_version) < Version('13.2'):
return SUSE11Distro()
else:
return SUSEDistro()
elif distro_name == "debian":
return DebianDistro()
elif distro_name == "redhat" or distro_name == "centos" or \
distro_name == "oracle":
if Version(distro_version) < Version("7"):
return Redhat6xDistro()
else:
return RedhatDistro()
else:
logger.warn("Unable to load distro implemetation for {0}.", distro_name)
logger.warn("Use default distro implemetation instead.")
return DefaultDistro()
def init_sysinfo(self):
osversion = "{0}:{1}-{2}-{3}:{4}".format(platform.system(),
DISTRO_NAME,
DISTRO_VERSION,
DISTRO_CODE_NAME,
platform.release())
self.sysinfo.append(TelemetryEventParam("OSVersion", osversion))
self.sysinfo.append(TelemetryEventParam("GAVersion", AGENT_LONG_VERSION))
try:
ram = self.distro.osutil.get_total_mem()
processors = self.distro.osutil.get_processor_cores()
self.sysinfo.append(TelemetryEventParam("RAM", ram))
self.sysinfo.append(TelemetryEventParam("Processors", processors))
except OSUtilError as e:
logger.warn("Failed to get system info: {0}", e)
try:
protocol = self.distro.protocol_util.get_protocol()
vminfo = protocol.get_vminfo()
self.sysinfo.append(TelemetryEventParam("VMName",
vminfo.vmName))
self.sysinfo.append(TelemetryEventParam("TenantName",
vminfo.tenantName))
self.sysinfo.append(TelemetryEventParam("RoleName",
vminfo.roleName))
self.sysinfo.append(TelemetryEventParam("RoleInstanceName",
vminfo.roleInstanceName))
self.sysinfo.append(TelemetryEventParam("ContainerId",
vminfo.containerId))
except ProtocolError as e:
logger.warn("Failed to get system info: {0}", e)
def get_first_if(self):
"""
Return the interface name, and ip addr of the
first active non-loopback interface.
"""
iface=''
expected=16 # how many devices should I expect...
struct_size=40 # for 64bit the size is 40 bytes
sock = socket.socket(socket.AF_INET,
socket.SOCK_DGRAM,
socket.IPPROTO_UDP)
buff=array.array('B', b'\0' * (expected * struct_size))
param = struct.pack('iL',
expected*struct_size,
buff.buffer_info()[0])
ret = fcntl.ioctl(sock.fileno(), 0x8912, param)
retsize=(struct.unpack('iL', ret)[0])
if retsize == (expected * struct_size):
logger.warn(('SIOCGIFCONF returned more than {0} up '
'network interfaces.'), expected)
sock = buff.tostring()
for i in range(0, struct_size * expected, struct_size):
iface=sock[i:i+16].split(b'\0', 1)[0]
if iface == b'lo':
continue
else:
break
return iface.decode('latin-1'), socket.inet_ntoa(sock[i+20:i+24])
def parse(self, xml_text):
"""
Parse xml tree, retreiving user and ssh key information.
Return self.
"""
wans = WA_NAME_SPACE
ovfns = OVF_NAME_SPACE
xml_doc = parse_doc(xml_text)
environment = find(xml_doc, "Environment", namespace=ovfns)
_validate_ovf(environment, "Environment not found")
section = find(environment, "ProvisioningSection", namespace=wans)
_validate_ovf(section, "ProvisioningSection not found")
version = findtext(environment, "Version", namespace=wans)
_validate_ovf(version, "Version not found")
if version > OVF_VERSION:
logger.warn("Newer provisioning configuration detected. "
"Please consider updating waagent")
conf_set = find(section, "LinuxProvisioningConfigurationSet",
namespace=wans)
_validate_ovf(conf_set, "LinuxProvisioningConfigurationSet not found")
self.hostname = findtext(conf_set, "HostName", namespace=wans)
_validate_ovf(self.hostname, "HostName not found")
self.username = findtext(conf_set, "UserName", namespace=wans)
_validate_ovf(self.username, "UserName not found")
self.user_password = findtext(conf_set, "UserPassword", namespace=wans)
self.customdata = findtext(conf_set, "CustomData", namespace=wans)
auth_option = findtext(conf_set, "DisableSshPasswordAuthentication",
namespace=wans)
if auth_option is not None and auth_option.lower() == "true":
self.disable_ssh_password_auth = True
else:
self.disable_ssh_password_auth = False
public_keys = findall(conf_set, "PublicKey", namespace=wans)
for public_key in public_keys:
path = findtext(public_key, "Path", namespace=wans)
fingerprint = findtext(public_key, "Fingerprint", namespace=wans)
value = findtext(public_key, "Value", namespace=wans)
self.ssh_pubkeys.append((path, fingerprint, value))
keypairs = findall(conf_set, "KeyPair", namespace=wans)
for keypair in keypairs:
path = findtext(keypair, "Path", namespace=wans)
fingerprint = findtext(keypair, "Fingerprint", namespace=wans)
self.ssh_keypairs.append((path, fingerprint))
def restore_rules_files(self, rules_files=__RULES_FILES__):
lib_dir = conf.get_lib_dir()
for dest in rules_files:
filename = fileutil.base_name(dest)
src = os.path.join(lib_dir, filename)
if os.path.isfile(dest):
continue
if os.path.isfile(src):
logger.warn("Move rules file {0} to {1}", filename, dest)
shutil.move(src, dest)
def download(self):
self.logger.info("Download extension package")
self.set_operation(WALAEventOperation.Download)
if self.pkg is None:
raise ExtensionError("No package uri found")
package = None
for uri in self.pkg.uris:
try:
package = self.protocol.download_ext_handler_pkg(uri.uri)
except ProtocolError as e:
logger.warn("Failed download extension: {0}", e)
if package is None:
raise ExtensionError("Failed to download extension")
self.logger.info("Unpack extension package")
pkg_file = os.path.join(conf.get_lib_dir(),
os.path.basename(uri.uri) + ".zip")
try:
fileutil.write_file(pkg_file, bytearray(package), asbin=True)
zipfile.ZipFile(pkg_file).extractall(self.get_base_dir())
except IOError as e:
raise ExtensionError(u"Failed to write and unzip plugin", e)
chmod = "find {0} -type f | xargs chmod u+x".format(self.get_base_dir())
shellutil.run(chmod)
self.report_event(message="Download succeeded")
self.logger.info("Initialize extension directory")
#Save HandlerManifest.json
man_file = fileutil.search_file(self.get_base_dir(),
'HandlerManifest.json')
if man_file is None:
raise ExtensionError("HandlerManifest.json not found")
try:
man = fileutil.read_file(man_file, remove_bom=True)
fileutil.write_file(self.get_manifest_file(), man)
except IOError as e:
raise ExtensionError(u"Failed to save HandlerManifest.json", e)
#Create status and config dir
try:
status_dir = self.get_status_dir()
fileutil.mkdir(status_dir, mode=0o700)
conf_dir = self.get_conf_dir()
fileutil.mkdir(conf_dir, mode=0o700)
except IOError as e:
raise ExtensionError(u"Failed to create status or config dir", e)
#Save HandlerEnvironment.json
self.create_handler_env()
def _send_dhcp_req(self, request):
__waiting_duration__ = [0, 10, 30, 60, 60]
for duration in __waiting_duration__:
try:
self.distro.osutil.allow_dhcp_broadcast()
response = socket_send(request)
validate_dhcp_resp(request, response)
return response
except DhcpError as e:
logger.warn("Failed to send DHCP request: {0}", e)
time.sleep(duration)
return None
def add_event(name, op="", is_success=True, duration=0, version="1.0",
message="", evt_type="", is_internal=False,
reporter=__event_logger__):
log = logger.info if is_success else logger.error
log("Event: name={0}, op={1}, message={2}", name, op, message)
if reporter.event_dir is None:
logger.warn("Event reporter is not initialized.")
return
reporter.add_event(name, op=op, is_success=is_success, duration=duration,
version=version, message=message, evt_type=evt_type,
is_internal=is_internal)
def get_ext_handler_pkgs(self, ext_handler):
ext_handler_pkgs = ExtHandlerPackageList()
data = None
for version_uri in ext_handler.versionUris:
try:
data, etag = self._get_data(version_uri.uri)
break
except ProtocolError as e:
logger.warn("Failed to get version uris: {0}", e)
logger.info("Retry getting version uris")
set_properties("extensionPackages", ext_handler_pkgs, data)
return ext_handler_pkgs
def daemon(self):
self.init_sysinfo()
last_heartbeat = datetime.datetime.min
period = datetime.timedelta(hours = 12)
while(True):
if (datetime.datetime.now()-last_heartbeat) > period:
last_heartbeat = datetime.datetime.now()
add_event(op=WALAEventOperation.HeartBeat, name="WALA",
is_success=True)
try:
self.collect_and_send_events()
except Exception as e:
logger.warn("Failed to send events: {0}", e)
time.sleep(60)
def call_storage_service(self, http_req, *args, **kwargs):
"""
Call storage service, handle SERVICE_UNAVAILABLE(503)
"""
for retry in range(0, 3):
resp = http_req(*args, **kwargs)
if resp.status == httpclient.SERVICE_UNAVAILABLE:
logger.warn("Storage service is not avaible temporaryly")
logger.info("Will retry later, in {0} seconds",
LONG_WAITING_INTERVAL)
time.sleep(LONG_WAITING_INTERVAL)
else:
return resp
raise ProtocolError(("Calling storage endpoint failed: {0}"
"").format(resp.status))
def check_wire_protocol_version(self):
uri = VERSION_INFO_URI.format(self.endpoint)
version_info_xml = self.fetch_config(uri, None)
version_info = VersionInfo(version_info_xml)
preferred = version_info.get_preferred()
if PROTOCOL_VERSION == preferred:
logger.info("Wire protocol version:{0}", PROTOCOL_VERSION)
elif PROTOCOL_VERSION in version_info.get_supported():
logger.info("Wire protocol version:{0}", PROTOCOL_VERSION)
logger.warn("Server prefered version:{0}", preferred)
else:
error = ("Agent supported wire protocol version: {0} was not "
"advised by Fabric.").format(PROTOCOL_VERSION)
raise ProtocolNotFoundError(error)
def handle_dhclient_restart(self):
if self.dhcpid is None:
logger.warn("Dhcp client is not running. ")
self.dhcpid = self.distro.osutil.get_dhcp_pid()
return
#The dhcp process hasn't changed since last check
if os.path.isdir(os.path.join('/proc', self.dhcpid.strip())):
return
newpid = self.distro.osutil.get_dhcp_pid()
if newpid is not None and newpid != self.dhcpid:
logger.info("EnvMonitor: Detected dhcp client restart. "
"Restoring routing table.")
self.distro.dhcp_handler.conf_routes()
self.dhcpid = newpid
def activate_resource_disk(self):
logger.info("Activate resource disk")
try:
mount_point = conf.get_resourcedisk_mountpoint()
fs = conf.get_resourcedisk_filesystem()
mount_point = self.mount_resource_disk(mount_point, fs)
warning_file = os.path.join(mount_point, DATALOSS_WARNING_FILE_NAME)
try:
fileutil.write_file(warning_file, DATA_LOSS_WARNING)
except IOError as e:
logger.warn("Failed to write data loss warnning:{0}", e)
return mount_point
except ResourceDiskError as e:
logger.error("Failed to mount resource disk {0}", e)
add_event(name="WALA", is_success=False, message=ustr(e),
op=WALAEventOperation.ActivateResourceDisk)
def save_event(self, data):
if self.event_dir is None:
logger.warn("Event reporter is not initialized.")
return
if not os.path.exists(self.event_dir):
os.mkdir(self.event_dir)
os.chmod(self.event_dir, 0o700)
if len(os.listdir(self.event_dir)) > 1000:
raise EventError("Too many files under: {0}".format(self.event_dir))
filename = os.path.join(self.event_dir, ustr(int(time.time()*1000000)))
try:
with open(filename+".tmp",'wb+') as hfile:
hfile.write(data.encode("utf-8"))
os.rename(filename+".tmp", filename+".tld")
except IOError as e:
raise EventError("Failed to write events to file:{0}", e)
def report_event(self, event_list):
buf = {}
#Group events by providerId
for event in event_list.events:
if event.providerId not in buf:
buf[event.providerId] = ""
event_str = event_to_v1(event)
if len(event_str) >= 63 * 1024:
logger.warn("Single event too large: {0}", event_str[300:])
continue
if len(buf[event.providerId] + event_str) >= 63 * 1024:
self.send_event(event.providerId, buf[event.providerId])
buf[event.providerId] = ""
buf[event.providerId] = buf[event.providerId] + event_str
#Send out all events left in buffer.
for provider_id in list(buf.keys()):
if len(buf[provider_id]) > 0:
self.send_event(provider_id, buf[provider_id])
def fetch_manifest(self, version_uris):
for version_uri in version_uris:
logger.verb("Fetch ext handler manifest: {0}", version_uri.uri)
try:
resp = self.call_storage_service(restutil.http_get,
version_uri.uri, None,
chk_proxy=True)
except HttpError as e:
raise ProtocolError(ustr(e))
if resp.status == httpclient.OK:
return self.decode_config(resp.read())
logger.warn("Failed to fetch ExtensionManifest: {0}, {1}",
resp.status, version_uri.uri)
logger.info("Will retry later, in {0} seconds",
LONG_WAITING_INTERVAL)
time.sleep(LONG_WAITING_INTERVAL)
raise ProtocolError(("Failed to fetch ExtensionManifest from "
"all sources"))
def call_wireserver(self, http_req, *args, **kwargs):
"""
Call wire server. Handle throttling(403) and Resource Gone(410)
"""
self.prevent_throttling()
for retry in range(0, 3):
resp = http_req(*args, **kwargs)
if resp.status == httpclient.FORBIDDEN:
logger.warn("Sending too much request to wire server")
logger.info("Sleep {0} second to avoid throttling.",
LONG_WAITING_INTERVAL)
time.sleep(LONG_WAITING_INTERVAL)
elif resp.status == httpclient.GONE:
msg = args[0] if len(args) > 0 else ""
raise WireProtocolResourceGone(msg)
else:
return resp
raise ProtocolError(("Calling wire server failed: {0}"
"").format(resp.status))
def http_request(method, url, data, headers=None, max_retry=3, chk_proxy=False):
"""
Sending http request to server
On error, sleep 10 and retry max_retry times.
"""
logger.verb("HTTP Req: {0} {1}", method, url)
logger.verb(" Data={0}", data)
logger.verb(" Header={0}", headers)
host, port, secure, rel_uri = _parse_url(url)
#Check proxy
proxy_host, proxy_port = (None, None)
if chk_proxy:
proxy_host, proxy_port = get_http_proxy()
#If httplib module is not built with ssl support. Fallback to http
if secure and not hasattr(httpclient, "HTTPSConnection"):
logger.warn("httplib is not built with ssl support")
secure = False
#If httplib module doesn't support https tunnelling. Fallback to http
if secure and \
proxy_host is not None and \
proxy_port is not None and \
not hasattr(httpclient.HTTPSConnection, "set_tunnel"):
logger.warn("httplib doesn't support https tunnelling(new in python 2.7)")
secure = False
for retry in range(0, max_retry):
try:
resp = _http_request(method, host, rel_uri, port=port, data=data,
secure=secure, headers=headers,
proxy_host=proxy_host, proxy_port=proxy_port)
logger.verb("HTTP Resp: Status={0}", resp.status)
logger.verb(" Header={0}", resp.getheaders())
return resp
except httpclient.HTTPException as e:
logger.warn('HTTPException {0}, args:{1}', e, repr(e.args))
except IOError as e:
logger.warn('Socket IOError {0}, args:{1}', e, repr(e.args))
if retry < max_retry - 1:
logger.info("Retry={0}, {1} {2}", retry, method, url)
time.sleep(RETRY_WAITING_INTERVAL)
if url is not None and len(url) > 100:
url_log = url[0: 100] #In case the url is too long
else:
url_log = url
raise HttpError("HTTP Err: {0} {1}".format(method, url_log))
def set_properties(name, obj, data):
if isinstance(obj, DataContract):
validata_param("Property '{0}'".format(name), data, dict)
for prob_name, prob_val in data.items():
prob_full_name = "{0}.{1}".format(name, prob_name)
try:
prob = getattr(obj, prob_name)
except AttributeError:
logger.warn("Unknown property: {0}", prob_full_name)
continue
prob = set_properties(prob_full_name, prob, prob_val)
setattr(obj, prob_name, prob)
return obj
elif isinstance(obj, DataContractList):
validata_param("List '{0}'".format(name), data, list)
for item_data in data:
item = obj.item_cls()
item = set_properties(name, item, item_data)
obj.append(item)
return obj
else:
return data
def mount_dvd(self, max_retry=6, chk_err=True):
dvd = self.get_dvd_device()
mount_point = conf.get_dvd_mount_point()
mountlist = shellutil.run_get_output("mount")[1]
existing = self.get_mount_point(mountlist, dvd)
if existing is not None: #Already mounted
logger.info("{0} is already mounted at {1}", dvd, existing)
return
if not os.path.isdir(mount_point):
os.makedirs(mount_point)
for retry in range(0, max_retry):
retcode = self.mount(dvd, mount_point, option="-o ro -t iso9660,udf",
chk_err=chk_err)
if retcode == 0:
logger.info("Successfully mounted dvd")
return
if retry < max_retry - 1:
logger.warn("Mount dvd failed: retry={0}, ret={1}", retry,
retcode)
time.sleep(5)
if chk_err:
raise OSUtilError("Failed to mount dvd.")
def http_request(method,
url,
data,
headers=None,
max_retry=3,
chk_proxy=False):
"""
Sending http request to server
On error, sleep 10 and retry max_retry times.
"""
logger.verb("HTTP Req: {0} {1}", method, url)
logger.verb(" Data={0}", data)
logger.verb(" Header={0}", headers)
host, port, secure, rel_uri = _parse_url(url)
#Check proxy
proxy_host, proxy_port = (None, None)
if chk_proxy:
proxy_host, proxy_port = get_http_proxy()
#If httplib module is not built with ssl support. Fallback to http
if secure and not hasattr(httpclient, "HTTPSConnection"):
logger.warn("httplib is not built with ssl support")
secure = False
#If httplib module doesn't support https tunnelling. Fallback to http
if secure and \
proxy_host is not None and \
proxy_port is not None and \
not hasattr(httpclient.HTTPSConnection, "set_tunnel"):
logger.warn(
"httplib doesn't support https tunnelling(new in python 2.7)")
secure = False
for retry in range(0, max_retry):
try:
resp = _http_request(method,
host,
rel_uri,
port=port,
data=data,
secure=secure,
headers=headers,
proxy_host=proxy_host,
proxy_port=proxy_port)
logger.verb("HTTP Resp: Status={0}", resp.status)
logger.verb(" Header={0}", resp.getheaders())
return resp
except httpclient.HTTPException as e:
logger.warn('HTTPException {0}, args:{1}', e, repr(e.args))
except IOError as e:
logger.warn('Socket IOError {0}, args:{1}', e, repr(e.args))
if retry < max_retry - 1:
logger.info("Retry={0}, {1} {2}", retry, method, url)
time.sleep(RETRY_WAITING_INTERVAL)
if url is not None and len(url) > 100:
url_log = url[0:100] #In case the url is too long
else:
url_log = url
raise HttpError("HTTP Err: {0} {1}".format(method, url_log))